Dogcows Code - chaz/homebank/blob - src/hb-tag.c

   1 /*  HomeBank -- Free, easy, personal accounting for everyone.
   2  *  Copyright (C) 1995-2014 Maxime DOYEN
   3  *
   4  *  This file is part of HomeBank.
   5  *
   6  *  HomeBank 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  *  HomeBank 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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "homebank.h"
  21 #include "hb-tag.h"
  22
  23 #define MYDEBUG 0
  24
  25 #if MYDEBUG
  26 #define DB(x) (x);
  27 #else
  28 #define DB(x);
  29 #endif
  30
  31 /* our global datas */
  32 extern struct HomeBank *GLOBALS;
  33
  34
  35 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  36
  37 void da_tag_free(Tag *item)
  38 {
  39         DB( g_print("da_tag_free\n") );
  40         if(item != NULL)
  41         {
  42                 DB( g_print(" => %d, %s\n", item->key, item->name) );
  43
  44                 g_free(item->name);
  45                 g_free(item);
  46         }
  47 }
  48
  49
  50 Tag *da_tag_malloc(void)
  51 {
  52         DB( g_print("da_tag_malloc\n") );
  53         return g_malloc0(sizeof(Tag));
  54 }
  55
  56
  57 void da_tag_destroy(void)
  58 {
  59         DB( g_print("da_tag_destroy\n") );
  60         g_hash_table_destroy(GLOBALS->h_tag);
  61 }
  62
  63
  64 void da_tag_new(void)
  65 {
  66         DB( g_print("da_tag_new\n") );
  67         GLOBALS->h_tag = g_hash_table_new_full(g_int_hash, g_int_equal, (GDestroyNotify)g_free, (GDestroyNotify)da_tag_free);
  68 }
  69
  70
  71 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
  72 static void da_tag_max_key_ghfunc(gpointer key, Tag *item, guint32 *max_key)
  73 {
  74         *max_key = MAX(*max_key, item->key);
  75 }
  76
  77 static gboolean da_tag_name_grfunc(gpointer key, Tag *item, gchar *name)
  78 {
  79         if( name && item->name )
  80         {
  81                 if(!strcasecmp(name, item->name))
  82                         return TRUE;
  83         }
  84         return FALSE;
  85 }
  86
  87 /**
  88  * da_tag_length:
  89  *
  90  * Return value: the number of elements
  91  */
  92 guint da_tag_length(void)
  93 {
  94         return g_hash_table_size(GLOBALS->h_tag);
  95 }
  96
  97 /**
  98  * da_tag_remove:
  99  *
 100  * remove an tag from the GHashTable
 101  *
 102  * Return value: TRUE if the key was found and removed
 103  *
 104  */
 105 gboolean da_tag_remove(guint32 key)
 106 {
 107         DB( g_print("da_tag_remove %d\n", key) );
 108
 109         return g_hash_table_remove(GLOBALS->h_tag, &key);
 110 }
 111
 112 /**
 113  * da_tag_insert:
 114  *
 115  * insert an tag into the GHashTable
 116  *
 117  * Return value: TRUE if inserted
 118  *
 119  */
 120 gboolean da_tag_insert(Tag *item)
 121 {
 122 guint32 *new_key;
 123
 124         DB( g_print("da_tag_insert\n") );
 125
 126         new_key = g_new0(guint32, 1);
 127         *new_key = item->key;
 128         g_hash_table_insert(GLOBALS->h_tag, new_key, item);
 129
 130         return TRUE;
 131 }
 132
 133
 134 /**
 135  * da_tag_append:
 136  *
 137  * append a new tag into the GHashTable
 138  *
 139  * Return value: TRUE if inserted
 140  *
 141  */
 142 gboolean da_tag_append(Tag *item)
 143 {
 144 Tag *existitem;
 145 guint32 *new_key;
 146
 147         DB( g_print("da_tag_append\n") );
 148
 149         if( item->name != NULL )
 150         {
 151                 /* ensure no duplicate */
 152                 //g_strstrip(item->name);
 153                 existitem = da_tag_get_by_name( item->name );
 154                 if( existitem == NULL )
 155                 {
 156                         new_key = g_new0(guint32, 1);
 157                         *new_key = da_tag_get_max_key() + 1;
 158                         item->key = *new_key;
 159
 160                         DB( g_print(" -> append id: %d\n", *new_key) );
 161
 162                         g_hash_table_insert(GLOBALS->h_tag, new_key, item);
 163                         return TRUE;
 164                 }
 165         }
 166
 167         DB( g_print(" -> %s already exist: %d\n", item->name, item->key) );
 168
 169         return FALSE;
 170 }
 171
 172 /**
 173  * da_tag_get_max_key:
 174  *
 175  * Get the biggest key from the GHashTable
 176  *
 177  * Return value: the biggest key value
 178  *
 179  */
 180 guint32 da_tag_get_max_key(void)
 181 {
 182 guint32 max_key = 0;
 183
 184         g_hash_table_foreach(GLOBALS->h_tag, (GHFunc)da_tag_max_key_ghfunc, &max_key);
 185         return max_key;
 186 }
 187
 188
 189
 190
 191 /**
 192  * da_tag_get_by_name:
 193  *
 194  * Get an tag structure by its name
 195  *
 196  * Return value: Tag * or NULL if not found
 197  *
 198  */
 199 Tag *da_tag_get_by_name(gchar *name)
 200 {
 201         DB( g_print("da_tag_get_by_name\n") );
 202
 203         return g_hash_table_find(GLOBALS->h_tag, (GHRFunc)da_tag_name_grfunc, name);
 204 }
 205
 206
 207
 208 /**
 209  * da_tag_get:
 210  *
 211  * Get an tag structure by key
 212  *
 213  * Return value: Tag * or NULL if not found
 214  *
 215  */
 216 Tag *da_tag_get(guint32 key)
 217 {
 218         DB( g_print("da_tag_get_tag\n") );
 219
 220         return g_hash_table_lookup(GLOBALS->h_tag, &key);
 221 }
 222
 223
 224
 225
 226
 227 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 228
 229 #if MYDEBUG
 230
 231 static void
 232 da_tag_debug_list_ghfunc(gpointer key, gpointer value, gpointer user_data)
 233 {
 234 guint32 *id = key;
 235 Tag *item = value;
 236
 237         DB( g_print(" %d :: %s\n", *id, item->name) );
 238
 239 }
 240
 241 static void
 242 da_tag_debug_list(void)
 243 {
 244
 245         DB( g_print("\n** debug **\n") );
 246
 247         g_hash_table_foreach(GLOBALS->h_tag, da_tag_debug_list_ghfunc, NULL);
 248
 249         DB( g_print("\n** end debug **\n") );
 250
 251 }
 252
 253 #endif
 254
 255 /* = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = */
 256
 257
 258
 259
 260 static gint
 261 tag_glist_name_compare_func(Tag *a, Tag *b)
 262 {
 263         return hb_string_utf8_compare(a->name, b->name);
 264 }
 265
 266
 267 static gint
 268 tag_glist_key_compare_func(Tag *a, Tag *b)
 269 {
 270         return a->key - b->key;
 271 }
 272
 273
 274 GList *tag_glist_sorted(gint column)
 275 {
 276 GList *list = g_hash_table_get_values(GLOBALS->h_tag);
 277
 278         if(column == 0)
 279                 return g_list_sort(list, (GCompareFunc)tag_glist_key_compare_func);
 280         else
 281                 return g_list_sort(list, (GCompareFunc)tag_glist_name_compare_func);
 282 }
 283
 284
 285
 286
 287