plugins/project-wizard/values.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3     values.c
   4     Copyright (C) 2004 Sebastien Granjoux
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  19 */
  20
  21 /*
  22  * Store all project property values (= just the name and the value
  23  * without other high level information like the associated widget)
  24  *
  25  * The property values are stored independently because we want to keep
  26  * all values entered by the user even if it goes back in the wizard and
  27  * regenerate all properties.
  28  * Moreover it removes dependencies between the installer part and the
  29  * properties. The installer part could work with the values only.
  30  *---------------------------------------------------------------------------*/
  31
  32 #include <config.h>
  33
  34 #include "values.h"
  35
  36 #include <string.h>
  37
  38 /*---------------------------------------------------------------------------*/
  39
  40 #define STRING_CHUNK_SIZE       256
  41
  42 /*---------------------------------------------------------------------------*/
  43
  44 /* This stores all the values. It's basically an hash table with a string
  45  * and a mem chunk to allocate all memories inside the object.
  46  * After adding a new property, there is no way to remove it, but you can
  47  * use the tag to mark it as obsolete */
  48
  49 struct _NPWValueHeap
  50 {
  51         GHashTable* hash;
  52         GStringChunk* string_pool;
  53         GMemChunk* value_pool;
  54 };
  55
  56 /* One property value, so just a name and a value plus a tag !
  57  * The tag is defined in the header file, but is not really used in this code */
  58
  59 struct _NPWValue
  60 {
  61         NPWValueTag tag;
  62         const gchar* name;
  63         const gchar* value;
  64 };
  65
  66 /* Creation and Destruction
  67  *---------------------------------------------------------------------------*/
  68
  69 static NPWValueHeap*
  70 npw_value_heap_initialize (NPWValueHeap* this)
  71 {
  72         this->string_pool = g_string_chunk_new (STRING_CHUNK_SIZE);
  73         this->value_pool = g_mem_chunk_new ("value pool", sizeof(NPWValue), (STRING_CHUNK_SIZE / 4) * sizeof(NPWValue), G_ALLOC_ONLY);
  74         this->hash = g_hash_table_new (g_str_hash, g_str_equal);
  75
  76         return this;
  77 }
  78
  79 static void
  80 npw_value_heap_deinitialize (NPWValueHeap* this)
  81 {
  82         g_string_chunk_free (this->string_pool);
  83         g_mem_chunk_destroy (this->value_pool);
  84         g_hash_table_destroy (this->hash);
  85 }
  86
  87
  88 NPWValueHeap*
  89 npw_value_heap_new (void)
  90 {
  91         NPWValueHeap* this;
  92
  93         this = g_new0 (NPWValueHeap, 1);
  94         return npw_value_heap_initialize (this);
  95 }
  96
  97 void
  98 npw_value_heap_free (NPWValueHeap* this)
  99 {
 100         /* GSList* node; */
 101         g_return_if_fail (this != NULL);
 102
 103         npw_value_heap_deinitialize (this);
 104         g_free (this);
 105 }
 106
 107 /* Find a value or list all values
 108  *---------------------------------------------------------------------------*/
 109
 110 /* Return key corresponding to name, create key if it doesn't exist */
 111
 112 NPWValue*
 113 npw_value_heap_find_value (NPWValueHeap* this, const gchar* name)
 114 {
 115         NPWValue* node;
 116
 117         if (!g_hash_table_lookup_extended (this->hash, name, NULL, (gpointer)&node))
 118         {
 119                 gchar* new_name;
 120
 121                 node = g_chunk_new (NPWValue, this->value_pool);
 122                 new_name = g_string_chunk_insert (this->string_pool, name);
 123                 node->name = new_name;
 124                 node->tag = NPW_EMPTY_VALUE;
 125                 node->value = NULL;
 126                 g_hash_table_insert (this->hash, new_name, node);
 127         }
 128
 129         return node;
 130 }
 131
 132 typedef struct _NPWValueHeapForeachValueData
 133 {
 134         NPWValueHeapForeachFunc func;
 135         gpointer data;
 136 } NPWValueHeapForeachValueData;
 137
 138 static void
 139 cb_value_heap_foreach_value (gpointer key, gpointer value, gpointer user_data)
 140 {
 141         NPWValueHeapForeachValueData* data = (NPWValueHeapForeachValueData *)user_data;
 142         NPWValue* node = (NPWValue*)value;
 143
 144         (data->func)(node->name, node->value, node->tag, data->data);
 145 }
 146
 147 void
 148 npw_value_heap_foreach_value (const NPWValueHeap* this, NPWValueHeapForeachFunc func, gpointer user_data)
 149 {
 150         NPWValueHeapForeachValueData data;
 151
 152         data.func = func;
 153         data.data = user_data;
 154         g_hash_table_foreach (this->hash, cb_value_heap_foreach_value, &data);
 155 }
 156
 157 /* Access value attributes
 158  *---------------------------------------------------------------------------*/
 159
 160 const gchar*
 161 npw_value_heap_get_name (const NPWValueHeap* this, const NPWValue* node)
 162 {
 163         g_return_val_if_fail (node != NULL, NULL);
 164
 165         return node->name;
 166 }
 167
 168 /* set new value, return FALSE if value has not changed */
 169
 170 gboolean
 171 npw_value_heap_set_value (NPWValueHeap* this, NPWValue* node, const gchar* value, NPWValueTag tag)
 172 {
 173         gboolean change = FALSE;
 174
 175         g_return_val_if_fail (node != NULL, FALSE);
 176
 177         if (tag == NPW_EMPTY_VALUE)
 178         {
 179                 if (node->tag != NPW_EMPTY_VALUE)
 180                 {
 181                         node->tag = NPW_EMPTY_VALUE;
 182                         change = TRUE;
 183                 }
 184         }
 185         else
 186         {
 187                 /* Set value */
 188                 if (value == NULL)
 189                 {
 190                         if (node->value != NULL)
 191                         {
 192                                 node->value = NULL;
 193                                 change = TRUE;
 194                         }
 195                 }
 196                 else
 197                 {
 198                         if ((node->value == NULL) || (strcmp (node->value, value) != 0))
 199                         {
 200                                 node->value = g_string_chunk_insert (this->string_pool, value);
 201                                 change = TRUE;
 202                         }
 203                 }
 204                 /* Set tag */
 205                 if (change == TRUE)
 206                 {
 207                         /* remove valid tag if value change */
 208                         node->tag &= ~NPW_VALID_VALUE;
 209                 }
 210                 else if ((tag & NPW_VALID_VALUE) != (node->tag & NPW_VALID_VALUE))
 211                 {
 212                         /* Changing valid tag count as a change */
 213                         change = TRUE;
 214                 }
 215                 node->tag &= NPW_VALID_VALUE;
 216                 node->tag |= tag;
 217         }
 218
 219         return change;
 220 }
 221
 222 const gchar*
 223 npw_value_heap_get_value (const NPWValueHeap* this, const NPWValue* node)
 224 {
 225         g_return_val_if_fail (node != NULL, NULL);
 226
 227         return node->tag == NPW_EMPTY_VALUE ? NULL : node->value;
 228 }
 229
 230 NPWValueTag
 231 npw_value_heap_get_tag (const NPWValueHeap* this, const NPWValue* node)
 232 {
 233         g_return_val_if_fail (node != NULL, NPW_EMPTY_VALUE);
 234
 235         return node->tag;
 236 }
 237
 238