e692754d79e6a11c3f7fa5021eba2cf98393388e
[claws.git] / src / addrcache.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 2001-2002 Match Grun
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 /*
21  * Functions to maintain address cache.
22  */
23
24 #include <glib.h>
25 #include <stdio.h>
26 #include <string.h>
27 #include <sys/stat.h>
28
29 #include "mgutils.h"
30 #include "addritem.h"
31 #include "addrcache.h"
32
33 #define ID_TIME_OFFSET             998000000
34 #define ADDRCACHE_MAX_SEARCH_COUNT 1000
35
36 static int _nextCacheID__ = 0;
37
38 /*
39  * Generate next cache ID.
40  */
41 static int addrcache_next_cache_id() {
42         int retVal;
43
44         if( _nextCacheID__ == 0 ) {
45                 _nextCacheID__ = 1;
46         }
47         retVal = _nextCacheID__;
48         ++_nextCacheID__;
49         return retVal;
50 }
51
52 /*
53 * Create new address cache.
54 */
55 AddressCache *addrcache_create() {
56         AddressCache *cache;
57         gint t;
58
59         cache = g_new0( AddressCache, 1 );
60         cache->itemHash = g_hash_table_new( g_str_hash, g_str_equal );
61         cache->cacheID = g_strdup_printf( "%d", addrcache_next_cache_id() );
62
63         cache->dataRead = FALSE;
64         cache->modified = FALSE;
65         cache->dirtyFlag = FALSE;
66         cache->name = NULL;
67         cache->modifyTime = 0;
68
69         /* Generate the next ID using system time */
70         cache->nextID = 1;
71         t = time( NULL );
72         if( t > 0 ) {
73                 cache->nextID = t - ID_TIME_OFFSET;
74         }
75
76         cache->tempList = NULL;
77         cache->rootFolder = addritem_create_item_folder();
78         cache->rootFolder->isRoot = TRUE;
79         ADDRITEM_PARENT(cache->rootFolder) = NULL;
80         return cache;
81 }
82
83 /*
84 * Properties.
85 */
86 ItemFolder *addrcache_get_root_folder( AddressCache *cache ) {
87         g_return_val_if_fail( cache != NULL, NULL );
88         return cache->rootFolder;
89 }
90 GList *addrcache_get_list_folder( AddressCache *cache ) {
91         g_return_val_if_fail( cache != NULL, NULL );
92         return cache->rootFolder->listFolder;
93 }
94 GList *addrcache_get_list_person( AddressCache *cache ) {
95         g_return_val_if_fail( cache != NULL, NULL );
96         return cache->rootFolder->listPerson;
97 }
98 gboolean addrcache_get_dirty( AddressCache *cache ) {
99         g_return_val_if_fail( cache != NULL, FALSE );
100         return cache->dirtyFlag;
101 }
102 void addrcache_set_dirty( AddressCache *cache, const gboolean value ) {
103         g_return_if_fail( cache != NULL );
104         cache->dirtyFlag = value;
105 }
106 gchar *addrcache_get_name( AddressCache *cache ) {
107         g_return_val_if_fail( cache != NULL, NULL );
108         return cache->name;
109 }
110 void addrcache_set_name( AddressCache *cache, const gchar *value ) {
111         g_return_if_fail( cache != NULL );
112         cache->name = mgu_replace_string( cache->name, value );
113         g_strstrip( cache->name );
114         cache->dirtyFlag = TRUE;
115 }
116
117 /*
118 * Generate next ID.
119 */
120 void addrcache_next_id( AddressCache *cache ) {
121         g_return_if_fail( cache != NULL );
122         cache->nextID++;
123 }
124
125 /*
126 * Refresh internal variables. This can be used force a reload.
127 */
128 void addrcache_refresh( AddressCache *cache ) {
129         cache->dataRead = FALSE;
130         cache->modified = TRUE;
131         cache->modifyTime = 0;
132 }
133
134 /*
135 * Free hash table visitor function.
136 */
137 static gint addrcache_free_item_vis( gpointer key, gpointer value, gpointer data ) {
138         AddrItemObject *obj = ( AddrItemObject * ) value;
139         if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
140                 /* Free person and their email */
141                 addritem_free_item_person( ( ItemPerson * ) obj );
142         }
143         else if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
144                 addritem_free_item_group( ( ItemGroup * ) obj );
145         }
146         else if( ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER ) {
147                 addritem_free_item_folder( ( ItemFolder * ) obj );
148         }
149         key = NULL;
150         value = NULL;
151         return 0;
152 }
153
154 /*
155 * Free hash table of address cache items.
156 */
157 static void addrcache_free_item_hash( GHashTable *table ) {
158         g_return_if_fail( table != NULL );
159         g_hash_table_freeze( table );
160         g_hash_table_foreach_remove( table, addrcache_free_item_vis, NULL );
161         g_hash_table_thaw( table );
162         g_hash_table_destroy( table );
163 }
164
165 /*
166 * Free up folders and groups.
167 */
168 static void addrcache_free_all_folders( ItemFolder *parent ) {
169         GList *node = parent->listFolder;
170         while( node ) {
171                 ItemFolder *folder = node->data;
172                 addrcache_free_all_folders( folder );
173                 node = g_list_next( node );
174         }
175         g_list_free( parent->listPerson );
176         g_list_free( parent->listGroup );
177         g_list_free( parent->listFolder );
178         parent->listPerson = NULL;
179         parent->listGroup = NULL;
180         parent->listFolder = NULL;
181 }
182
183 /*
184 * Clear the address cache.
185 */
186 void addrcache_clear( AddressCache *cache ) {
187         g_return_if_fail( cache != NULL );
188
189         /* Free up folders and hash table */
190         addrcache_free_all_folders( cache->rootFolder );
191         addrcache_free_item_hash( cache->itemHash );
192         cache->itemHash = NULL;
193         ADDRITEM_PARENT(cache->rootFolder) = NULL;
194         addritem_free_item_folder( cache->rootFolder );
195         cache->rootFolder = NULL;
196         g_list_free( cache->tempList );
197         cache->tempList = NULL;
198
199         /* Reset to initial state */
200         cache->itemHash = g_hash_table_new( g_str_hash, g_str_equal );
201         cache->rootFolder = addritem_create_item_folder();
202         cache->rootFolder->isRoot = TRUE;
203         ADDRITEM_PARENT(cache->rootFolder) = NULL;
204
205         addrcache_refresh( cache );
206
207 }
208
209 /*
210 * Free address cache.
211 */
212 void addrcache_free( AddressCache *cache ) {
213         g_return_if_fail( cache != NULL );
214
215         cache->dirtyFlag = FALSE;
216         addrcache_free_all_folders( cache->rootFolder );
217         addrcache_free_item_hash( cache->itemHash );
218         cache->itemHash = NULL;
219         ADDRITEM_PARENT(cache->rootFolder) = NULL;
220         addritem_free_item_folder( cache->rootFolder );
221         cache->rootFolder = NULL;
222         g_list_free( cache->tempList );
223         cache->tempList = NULL;
224         g_free( cache->cacheID );
225         cache->cacheID = NULL;
226         g_free( cache->name );
227         cache->name = NULL;
228         g_free( cache );
229 }
230
231 /*
232 * Check whether file has changed by comparing with cache.
233 * return: TRUE if file has changed.
234 */
235 gboolean addrcache_check_file( AddressCache *cache, gchar *path ) {
236         gboolean retVal;
237         struct stat filestat;
238         retVal = TRUE;
239         if( path ) {
240                 if( 0 == lstat( path, &filestat ) ) {
241                         if( filestat.st_mtime == cache->modifyTime ) retVal = FALSE;
242                 }
243         }
244         return retVal;
245 }
246
247 /*
248 * Save file time to cache.
249 * return: TRUE if time marked.
250 */
251 gboolean addrcache_mark_file( AddressCache *cache, gchar *path ) {
252         gboolean retVal = FALSE;
253         struct stat filestat;
254         if( path ) {
255                 if( 0 == lstat( path, &filestat ) ) {
256                         cache->modifyTime = filestat.st_mtime;
257                         retVal = TRUE;
258                 }
259         }
260         return retVal;
261 }
262
263 /*
264 * Print list of items.
265 */
266 void addrcache_print_item_list( GList *list, FILE *stream ) {
267         GList *node = list;
268         while( node ) {
269                 AddrItemObject *obj = node->data;
270                 if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
271                         addritem_print_item_person( ( ItemPerson * ) obj, stream );
272                 }
273                 else if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
274                         addritem_print_item_group( ( ItemGroup * ) obj, stream );
275                 }
276                 else if( ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER ) {
277                         addritem_print_item_folder( ( ItemFolder * ) obj, stream );
278                 }
279                 node = g_list_next( node );
280         }
281         fprintf( stream, "\t---\n" );
282 }
283
284 /*
285 * Print item hash table visitor function.
286 */
287 static void addrcache_print_item_vis( gpointer key, gpointer value, gpointer data ) {
288         AddrItemObject *obj = ( AddrItemObject * ) value;
289         FILE *stream = ( FILE * ) data;
290         if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
291                 addritem_print_item_person( ( ItemPerson * ) obj, stream );
292         }
293         else if( ADDRITEM_TYPE(obj) == ITEMTYPE_EMAIL ) {
294                 printf( "addrcache: print email\n" );
295         }
296         else if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
297                 addritem_print_item_group( ( ItemGroup * ) obj, stream );
298         }
299         else if( ADDRITEM_TYPE(obj) == ITEMTYPE_FOLDER ) {
300                 addritem_print_item_folder( ( ItemFolder * ) obj, stream );
301         }
302 }
303
304 /*
305 * Dump entire address cache hash table contents.
306 */
307 void addrcache_print( AddressCache *cache, FILE *stream ) {
308         g_return_if_fail( cache != NULL );
309         fprintf( stream, "AddressCache:\n" );
310         fprintf( stream, "cache id : %s\n",  cache->cacheID );
311         fprintf( stream, "next id  : %d\n",  cache->nextID );
312         fprintf( stream, "name     : %s\n",  cache->name );
313         fprintf( stream, "mod time : %ld\n", cache->modifyTime );
314         fprintf( stream, "modified : %s\n",  cache->modified ? "yes" : "no" );
315         fprintf( stream, "data read: %s\n",  cache->dataRead ? "yes" : "no" );
316 }
317
318 /*
319 * Dump entire address cache hash table contents.
320 */
321 void addrcache_dump_hash( AddressCache *cache, FILE *stream ) {
322         g_return_if_fail( cache != NULL );
323         addrcache_print( cache, stream );
324         g_hash_table_foreach( cache->itemHash, addrcache_print_item_vis, stream );
325 }
326
327 /*
328  * Allocate ID for person.
329  */
330 void addrcache_id_person( AddressCache *cache, ItemPerson *person ) {
331         g_return_if_fail( cache != NULL );
332         g_return_if_fail( person != NULL );
333         if( ADDRITEM_ID(person) ) return;
334         addrcache_next_id( cache );
335         ADDRITEM_ID(person) = g_strdup_printf( "%d", cache->nextID );
336 }
337
338 /*
339  * Allocate ID for group.
340  */
341 void addrcache_id_group( AddressCache *cache, ItemGroup *group ) {
342         g_return_if_fail( cache != NULL );
343         g_return_if_fail( group != NULL );
344         if( ADDRITEM_ID(group) ) return;
345         addrcache_next_id( cache );
346         ADDRITEM_ID(group) = g_strdup_printf( "%d", cache->nextID );
347 }
348
349 /*
350  * Allocate ID for folder.
351  */
352 void addrcache_id_folder( AddressCache *cache, ItemFolder *folder ) {
353         g_return_if_fail( cache != NULL );
354         g_return_if_fail( folder != NULL );
355         if( ADDRITEM_ID(folder) ) return;
356         addrcache_next_id( cache );
357         ADDRITEM_ID(folder) = g_strdup_printf( "%d", cache->nextID );
358 }
359
360 /*
361  * Allocate ID for email address.
362  */
363 void addrcache_id_email( AddressCache *cache, ItemEMail *email ) {
364         g_return_if_fail( cache != NULL );
365         g_return_if_fail( email != NULL );
366         if( ADDRITEM_ID(email) ) return;
367         addrcache_next_id( cache );
368         ADDRITEM_ID(email) = g_strdup_printf( "%d", cache->nextID );
369 }
370
371 /*
372  * Allocate ID for user attribute.
373  */
374 void addrcache_id_attribute( AddressCache *cache, UserAttribute *attrib ) {
375         g_return_if_fail( cache != NULL );
376         g_return_if_fail( attrib != NULL );
377         if( attrib->uid ) return;
378         addrcache_next_id( cache );
379         attrib->uid = g_strdup_printf( "%d", cache->nextID );
380 }
381
382 /*
383 * Add person to hash table.
384 * return: TRUE if item added.
385 */
386 gboolean addrcache_hash_add_person( AddressCache *cache, ItemPerson *person ) {
387         if( g_hash_table_lookup( cache->itemHash, ADDRITEM_ID(person) ) ) {
388                 return FALSE;
389         }
390         g_hash_table_insert( cache->itemHash, ADDRITEM_ID(person), person );
391         return TRUE;
392 }
393
394 /*
395 * Add email to hash table.
396 * return: TRUE if item added.
397 */
398 gboolean addrcache_hash_add_email( AddressCache *cache, ItemEMail *email ) {
399         if( g_hash_table_lookup( cache->itemHash, ADDRITEM_ID(email) ) ) {
400                 return FALSE;
401         }
402         g_hash_table_insert( cache->itemHash, ADDRITEM_ID(email), email );
403         return TRUE;
404 }
405
406 /*
407 * Add group to hash table.
408 * return: TRUE if item added.
409 */
410 gboolean addrcache_hash_add_group( AddressCache *cache, ItemGroup *group ) {
411         g_return_val_if_fail( cache != NULL, FALSE );
412         g_return_val_if_fail( group != NULL, FALSE );
413
414         if( g_hash_table_lookup( cache->itemHash, ADDRITEM_ID(group) ) ) {
415                 return FALSE;
416         }
417         g_hash_table_insert( cache->itemHash, ADDRITEM_ID(group), group );
418         return TRUE;
419 }
420
421 /*
422 * Add folder to hash table.
423 * return: TRUE if item added.
424 */
425 gboolean addrcache_hash_add_folder( AddressCache *cache, ItemFolder *folder ) {
426         g_return_val_if_fail( cache != NULL, FALSE );
427         g_return_val_if_fail( folder != NULL, FALSE );
428
429         if( g_hash_table_lookup( cache->itemHash, ADDRITEM_ID(folder) ) ) {
430                 return FALSE;
431         }
432         g_hash_table_insert( cache->itemHash, ADDRITEM_ID(folder), folder );
433         return TRUE;
434 }
435
436 /*
437 * Add person to specified folder in cache.
438 */
439 gboolean addrcache_folder_add_person( AddressCache *cache, ItemFolder *folder, ItemPerson *item ) {
440         gboolean retVal = FALSE;
441
442         g_return_val_if_fail( cache != NULL, FALSE );
443         g_return_val_if_fail( folder != NULL, FALSE );
444         g_return_val_if_fail( item != NULL, FALSE );
445
446         retVal = addrcache_hash_add_person( cache, item );
447         if( retVal ) {
448                 addritem_folder_add_person( folder, item );
449                 cache->dirtyFlag = TRUE;
450         }
451         return retVal;
452 }
453
454 /*
455 * Add folder to specified folder in cache.
456 */
457 gboolean addrcache_folder_add_folder( AddressCache *cache, ItemFolder *folder, ItemFolder *item ) {
458         gboolean retVal = FALSE;
459
460         g_return_val_if_fail( cache != NULL, FALSE );
461         g_return_val_if_fail( folder != NULL, FALSE );
462         g_return_val_if_fail( item != NULL, FALSE );
463
464         retVal = addrcache_hash_add_folder( cache, item );
465         if( retVal ) {
466                 addritem_folder_add_folder( folder, item );
467                 cache->dirtyFlag = TRUE;
468         }
469         return TRUE;
470 }
471
472 /*
473 * Add folder to specified folder in cache.
474 */
475 gboolean addrcache_folder_add_group( AddressCache *cache, ItemFolder *folder, ItemGroup *item ) {
476         gboolean retVal = FALSE;
477
478         g_return_val_if_fail( cache != NULL, FALSE );
479         g_return_val_if_fail( folder != NULL, FALSE );
480         g_return_val_if_fail( item != NULL, FALSE );
481
482         retVal = addrcache_hash_add_group( cache, item );
483         if( retVal ) {
484                 addritem_folder_add_group( folder, item );
485                 cache->dirtyFlag = TRUE;
486         }
487         return retVal;
488 }
489
490 /*
491 * Add person to address cache.
492 * return: TRUE if item added.
493 */
494 gboolean addrcache_add_person( AddressCache *cache, ItemPerson *person ) {
495         gboolean retVal = FALSE;
496
497         g_return_val_if_fail( cache != NULL, FALSE );
498         g_return_val_if_fail( person != NULL, FALSE );
499
500         retVal = addrcache_hash_add_person( cache, person );
501         if( retVal ) {
502                 addritem_folder_add_person( cache->rootFolder, person );
503                 cache->dirtyFlag = TRUE;
504         }
505         return retVal;
506 }
507
508 /*
509 * Add EMail address to person.
510 * return: TRUE if item added.
511 */
512 gboolean addrcache_person_add_email( AddressCache *cache, ItemPerson *person, ItemEMail *email ) {
513         gboolean retVal = FALSE;
514
515         g_return_val_if_fail( cache != NULL, FALSE );
516         g_return_val_if_fail( person != NULL, FALSE );
517         g_return_val_if_fail( email != NULL, FALSE );
518
519         retVal = addrcache_hash_add_email( cache, email );
520         if( retVal ) {
521                 addritem_person_add_email( person, email );
522                 cache->dirtyFlag = TRUE;
523         }
524         return retVal;
525 }
526
527 /*
528 * Add group to address cache.
529 * return: TRUE if item added.
530 */
531 gboolean addrcache_add_group( AddressCache *cache, ItemGroup *group ) {
532         gboolean retVal = FALSE;
533
534         g_return_val_if_fail( cache != NULL, FALSE );
535         g_return_val_if_fail( group != NULL, FALSE );
536
537         retVal = addrcache_hash_add_group( cache, group );
538         if( retVal ) {
539                 addritem_folder_add_group( cache->rootFolder, group );
540                 cache->dirtyFlag = TRUE;
541         }
542         return retVal;
543 }
544
545 /*
546 * Add EMail address to person.
547 * return: TRUE if item added.
548 */
549 gboolean addrcache_group_add_email( AddressCache *cache, ItemGroup *group, ItemEMail *email ) {
550         g_return_val_if_fail( cache != NULL, FALSE );
551         g_return_val_if_fail( group != NULL, FALSE );
552         g_return_val_if_fail( email != NULL, FALSE );
553
554         addritem_group_add_email( group, email );
555         cache->dirtyFlag = TRUE;
556         return TRUE;
557 }
558
559 /*
560 * Add folder to address cache.
561 * return: TRUE if item added.
562 */
563 gboolean addrcache_add_folder( AddressCache *cache, ItemFolder *folder ) {
564         gboolean retVal = FALSE;
565
566         g_return_val_if_fail( cache != NULL, FALSE );
567         g_return_val_if_fail( folder != NULL, FALSE );
568
569         retVal = addrcache_hash_add_folder( cache, folder );
570         if( retVal ) {
571                 addritem_folder_add_folder( cache->rootFolder, folder );
572                 cache->dirtyFlag = TRUE;
573         }
574         return retVal;
575 }
576
577 /*
578 * Move person to destination folder.
579 * Enter: cache  Cache.
580 *        person Person to move.
581 *        target Target folder.
582 */
583 void addrcache_folder_move_person(
584         AddressCache *cache, ItemPerson *person, ItemFolder *target )
585 {
586         ItemFolder *parent;
587
588         g_return_if_fail( cache != NULL );
589         g_return_if_fail( person != NULL );
590
591         parent = ( ItemFolder * ) ADDRITEM_PARENT(person);
592         if( ! parent ) parent = cache->rootFolder;
593         parent->listPerson = g_list_remove( parent->listPerson, person );
594         target->listPerson = g_list_append( target->listPerson, person );
595         ADDRITEM_PARENT(person) = ADDRITEM_OBJECT(target);
596         cache->dirtyFlag = TRUE;
597 }
598
599 /*
600 * Move group to destination folder.
601 * Enter: cache  Cache.
602 *        group  Group to move.
603 *        target Target folder.
604 */
605 void addrcache_folder_move_group(
606         AddressCache *cache, ItemGroup *group, ItemFolder *target )
607 {
608         ItemFolder *parent;
609
610         g_return_if_fail( cache != NULL );
611         g_return_if_fail( group != NULL );
612
613         parent = ( ItemFolder * ) ADDRITEM_PARENT(group);
614         if( ! parent ) parent = cache->rootFolder;
615         parent->listGroup = g_list_remove( parent->listGroup, group );
616         target->listGroup = g_list_append( target->listGroup, group );
617         ADDRITEM_PARENT(group) = ADDRITEM_OBJECT(target);
618         cache->dirtyFlag = TRUE;
619 }
620
621 /*
622 * Move folder to destination folder.
623 * Enter: cache  Cache.
624 *        folder Folder to move.
625 *        target Target folder.
626 */
627 void addrcache_folder_move_folder(
628         AddressCache *cache, ItemFolder *folder, ItemFolder *target )
629 {
630         ItemFolder *parent;
631
632         g_return_if_fail( cache != NULL );
633         g_return_if_fail( folder != NULL );
634
635         parent = ( ItemFolder * ) ADDRITEM_PARENT(folder);
636         if( ! parent ) parent = cache->rootFolder;
637         parent->listFolder = g_list_remove( parent->listFolder, folder );
638         target->listFolder = g_list_append( target->listFolder, folder );
639         ADDRITEM_PARENT(folder) = ADDRITEM_OBJECT(target);
640         cache->dirtyFlag = TRUE;
641 }
642
643 /*
644 * Return pointer to object (either person or group) for specified ID.
645 * param: uid Object ID.
646 * return: Object, or NULL if not found.
647 */
648 AddrItemObject *addrcache_get_object( AddressCache *cache, const gchar *uid ) {
649         AddrItemObject *obj = NULL;
650         gchar *uidH;
651
652         g_return_val_if_fail( cache != NULL, NULL );
653
654         if( uid == NULL || *uid == '\0' ) return NULL;
655         obj = ( AddrItemObject * ) g_hash_table_lookup( cache->itemHash, uid );
656         if( obj ) {
657                 /* Check for matching UID */
658                 uidH = ADDRITEM_ID(obj);
659                 if( uidH ) {
660                         if( strcmp( uidH, uid ) == 0 ) return obj;
661                 }
662         }
663         return NULL;
664 }
665
666 /*
667 * Return pointer for specified object ID.
668 * param: uid Object ID.
669 * return: Person object, or NULL if not found.
670 */
671 ItemPerson *addrcache_get_person( AddressCache *cache, const gchar *uid ) {
672         ItemPerson *person = NULL;
673         AddrItemObject *obj = addrcache_get_object( cache, uid );
674
675         if( obj ) {
676                 if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
677                         person = ( ItemPerson * ) obj;
678                 }
679         }
680         return person;
681 }
682
683 /*
684 * Return pointer for specified object ID.
685 * param: uid group ID.
686 * return: Group object, or NULL if not found.
687 */
688 ItemGroup *addrcache_get_group( AddressCache *cache, const gchar *uid ) {
689         ItemGroup *group = NULL;
690         AddrItemObject *obj = addrcache_get_object( cache, uid );
691
692         if( obj ) {
693                 if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
694                         group = ( ItemGroup * ) obj;
695                 }
696         }
697         return group;
698 }
699
700 /*
701 * Find email address in address cache.
702 * param: eid    EMail ID.
703 * return: email object for specified object ID and email ID, or NULL if not found.
704 */
705 ItemEMail *addrcache_get_email( AddressCache *cache, const gchar *eid ) {
706         ItemEMail *email = NULL;
707         AddrItemObject *obj = addrcache_get_object( cache, eid );
708
709         if( obj ) {
710                 if( ADDRITEM_TYPE(obj) == ITEMTYPE_EMAIL ) {
711                         email = ( ItemEMail * ) obj;
712                 }
713         }
714         return email;
715 }
716
717 /*
718 * Remove attribute from person.
719 * param: uid    Object ID for person.
720 *        aid    Attribute ID.
721 * return: UserAttribute object, or NULL if not found. Note that object should still be freed.
722 */
723 UserAttribute *addrcache_person_remove_attrib_id( AddressCache *cache, const gchar *uid, const gchar *aid ) {
724         UserAttribute *attrib = NULL;
725         ItemPerson *person;
726
727         if( aid == NULL || *aid == '\0' ) return NULL;
728
729         person = addrcache_get_person( cache, uid );
730         if( person ) {
731                 attrib = addritem_person_remove_attrib_id( person, aid );
732                 cache->dirtyFlag = TRUE;
733         }
734         return attrib;
735 }
736
737 /*
738 * Remove attribute from person.
739 * param: person Person.
740 *        attrib Attribute to remove.
741 * return: UserAttribute object. Note that object should still be freed.
742 */
743 UserAttribute *addrcache_person_remove_attribute( AddressCache *cache, ItemPerson *person, UserAttribute *attrib ) {
744         UserAttribute *found = NULL;
745
746         g_return_val_if_fail( cache != NULL, NULL );
747
748         if( person && attrib ) {
749                 found = addritem_person_remove_attribute( person, attrib );
750                 cache->dirtyFlag = TRUE;
751         }
752         return found;
753 }
754
755 /*
756 * Remove group from address cache.
757 * param: group  Group to remove.
758 * return: Group, or NULL if not found. Note that object should still be freed.
759 */
760 ItemGroup *addrcache_remove_group( AddressCache *cache, ItemGroup *group ) {
761         AddrItemObject *obj = NULL;
762
763         g_return_val_if_fail( cache != NULL, NULL );
764
765         if( group ) {
766                 gchar *uid = ADDRITEM_ID(group);
767                 if( uid == NULL || *uid == '\0' ) return NULL;
768                 obj = ( AddrItemObject * ) g_hash_table_lookup( cache->itemHash, uid );
769                 if( obj ) {
770                         ItemFolder *parent = ( ItemFolder * ) ADDRITEM_PARENT(group);
771                         if( ! parent ) parent = cache->rootFolder;
772
773                         /* Remove group from parent's list and hash table */
774                         parent->listGroup = g_list_remove( parent->listGroup, obj );
775                         g_hash_table_remove( cache->itemHash, uid );
776                         cache->dirtyFlag = TRUE;
777                         return group;
778                 }
779         }
780         return NULL;
781 }
782
783 /*
784 * Remove specified email from address cache. Note that object is only
785 * removed from cache and not parent objects.
786 * param: email  EMail to remove.
787 * return: EMail, or NULL if not found. Note that object should still be freed.
788 */
789 ItemEMail *addrcache_remove_email( AddressCache *cache, ItemEMail *email ) {
790         AddrItemObject *obj = NULL;
791
792         g_return_val_if_fail( cache != NULL, NULL );
793
794         if( email ) {
795                 gchar *eid = ADDRITEM_ID(email);
796                 if( eid == NULL || *eid == '\0' ) return NULL;
797                 obj = ( AddrItemObject * ) g_hash_table_lookup( cache->itemHash, eid );
798                 if( obj ) {
799                         if( ADDRITEM_TYPE(obj) == ITEMTYPE_EMAIL ) {
800                                 /* Remove email addresses from hash table. */
801                                 g_hash_table_remove( cache->itemHash, eid );
802                                 cache->dirtyFlag = TRUE;
803                                 return email;
804                         }
805                 }
806         }
807         return NULL;
808 }
809
810 /*
811 * Hash table visitor function to remove email from group.
812 */
813 static void addrcache_allgrp_rem_email_vis( gpointer key, gpointer value, gpointer data ) {
814         AddrItemObject *obj = ( AddrItemObject * ) value;
815         ItemEMail *email = ( ItemEMail * ) data;
816
817         if( ! email ) return;
818         if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
819                 ItemGroup *group = ( ItemGroup * ) value;
820                 if( group ) {
821                         /* Remove each email address that belongs to the person from the list */
822                         group->listEMail = g_list_remove( group->listEMail, email );
823                 }
824         }
825 }
826
827 /*
828 * Remove specified person from address cache.
829 * param: person Person to remove.
830 * return: Person, or NULL if not found. Note that object should still be freed.
831 */
832 ItemPerson *addrcache_remove_person( AddressCache *cache, ItemPerson *person ) {
833         AddrItemObject *obj = NULL;
834         gchar *uid;
835
836         g_return_val_if_fail( cache != NULL, NULL );
837
838         if( person ) {
839                 uid = ADDRITEM_ID(person);
840                 if( uid == NULL || *uid == '\0' ) return NULL;
841                 obj = ( AddrItemObject * ) g_hash_table_lookup( cache->itemHash, uid );
842                 if( obj ) {
843                         if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
844                                 ItemFolder *parent;
845                                 GList *node;
846
847                                 /* Remove all email addresses for person */
848                                 /* from groups and from hash table */
849                                 node = person->listEMail;
850                                 while( node ) {
851                                         ItemEMail *email;
852                                         gchar *eid;
853
854                                         email = node->data;
855                                         g_hash_table_foreach( cache->itemHash,
856                                                 addrcache_allgrp_rem_email_vis, email );
857                                         eid = ADDRITEM_ID( email );
858                                         g_hash_table_remove( cache->itemHash, eid );
859                                         node = g_list_next( node );
860                                 }
861
862                                 /* Remove person from owning folder */
863                                 parent = ( ItemFolder * ) ADDRITEM_PARENT(person);
864                                 if( ! parent ) parent = cache->rootFolder;
865                                 parent->listPerson = g_list_remove( parent->listPerson, person );
866                                 g_hash_table_remove( cache->itemHash, uid );
867                                 cache->dirtyFlag = TRUE;
868                                 return person;
869                         }
870                 }
871         }
872         return NULL;
873 }
874
875 /*
876 * Remove email address in address cache for specified person.
877 * param: person Person.
878 *        email  EMail to remove.
879 * return: EMail object, or NULL if not found. Note that object should still be freed.
880 */
881 ItemEMail *addrcache_person_remove_email( AddressCache *cache, ItemPerson *person, ItemEMail *email ) {
882         ItemEMail *found = NULL;
883
884         g_return_val_if_fail( cache != NULL, NULL );
885
886         if( person && email ) {
887                 found = addritem_person_remove_email( person, email );
888                 if( found ) {
889                         /* Remove email from all groups. */
890                         g_hash_table_foreach( cache->itemHash, addrcache_allgrp_rem_email_vis, email );
891
892                         /* Remove email from person's address list */
893                         if( person->listEMail ) {
894                                 person->listEMail = g_list_remove( person->listEMail, email );
895                         }
896                         /* Unlink reference to person. */
897                         ADDRITEM_PARENT(email) = NULL;
898                         cache->dirtyFlag = TRUE;
899                 }
900         }
901         return found;
902 }
903
904 /*
905 * Move email address in address cache to new person. If member of group, address
906 * remains in group.
907 * param: cache  Cache.
908 *        email  EMail to remove.
909 *        target Target person.
910 * return: EMail object, or NULL if not found. Note that object should still be freed.
911 */
912 void addrcache_person_move_email(
913         AddressCache *cache, ItemEMail *email, ItemPerson *target )
914 {
915         ItemPerson *person;
916
917         g_return_if_fail( cache != NULL );
918
919         if( email == NULL ) return;
920         if( target == NULL ) return;
921
922         person = ( ItemPerson * ) ADDRITEM_PARENT(email);
923         if( person ) {
924                 ItemEMail *found;
925                 found = addritem_person_remove_email( person, email );
926                 if( found ) {
927                         if( person->listEMail ) {
928                                 person->listEMail = g_list_remove( person->listEMail, found );
929                                 addritem_person_add_email( target, found );
930                                 cache->dirtyFlag = TRUE;
931                         }
932                 }
933         }
934 }
935
936 /*
937 * Return link list of address items for root level folder. Note that the list contains
938 * references to items and should be g_free() when done. Do *NOT* attempt to use the
939 * addrcache_free_xxx() functions... this will destroy the address cache data!
940 * Return: List of items, or NULL if none.
941 */
942 GList *addrcache_folder_get_address_list( AddressCache *cache, ItemFolder *folder ) {
943         GList *list = NULL;
944         GList *node = NULL;
945         ItemFolder *f = folder;
946
947         g_return_val_if_fail( cache != NULL, NULL );
948
949         if( ! f ) f = cache->rootFolder;
950         node = f->listPerson;
951         while( node ) {
952                 list = g_list_append( list, node->data );
953                 node = g_list_next( node );
954         }
955         node = f->listGroup;
956         while( node ) {
957                 list = g_list_append( list, node->data );
958                 node = g_list_next( node );
959         }
960         return list;
961 }
962
963 /*
964 * Return link list of persons for specified folder. Note that the list contains
965 * references to items and should be g_free() when done. Do *NOT* attempt to use the
966 * addrcache_free_xxx() functions... this will destroy the address cache data!
967 * Return: List of items, or NULL if none.
968 */
969 GList *addrcache_folder_get_person_list( AddressCache *cache, ItemFolder *folder ) {
970         ItemFolder *f = folder;
971
972         g_return_val_if_fail( cache != NULL, NULL );
973
974         if( ! f ) f = cache->rootFolder;
975         return addritem_folder_get_person_list( f );
976 }
977
978 /*
979 * Return link list of group items for specified folder. Note that the list contains
980 * references to items and should be g_free() when done. Do *NOT* attempt to use the
981 * addrcache_free_xxx() functions... this will destroy the address cache data!
982 * Return: List of items, or NULL if none.
983 */
984 GList *addrcache_folder_get_group_list( AddressCache *cache, ItemFolder *folder ) {
985         ItemFolder *f = folder;
986
987         g_return_val_if_fail( cache != NULL, NULL );
988
989         if( ! f ) f = cache->rootFolder;
990         return addritem_folder_get_group_list( f );
991 }
992
993 /*
994 * Return link list of folder items for specified folder. Note that the list contains
995 * references to items and should be g_free() when done. Do *NOT* attempt to used the
996 * addrcache_free_xxx() functions... this will destroy the address cache data!
997 * Return: List of items, or NULL if none.
998 */
999 GList *addrcache_folder_get_folder_list( AddressCache *cache, ItemFolder *folder ) {
1000         GList *node = NULL;
1001         GList *list = NULL;
1002         ItemFolder *f = folder;
1003
1004         g_return_val_if_fail( cache != NULL, NULL );
1005
1006         if( ! f ) f = cache->rootFolder;
1007         node = f->listFolder;
1008         while( node ) {
1009                 list = g_list_append( list, node->data );
1010                 node = g_list_next( node );
1011         }
1012         return list;
1013 }
1014
1015 /*
1016 * Return link list of address items for root level folder. Note that the list contains
1017 * references to items and should be g_free() when done. Do *NOT* attempt to used the
1018 * addrcache_free_xxx() functions... this will destroy the address cache data!
1019 * Return: List of items, or NULL if none.
1020 */
1021 GList *addrcache_get_address_list( AddressCache *cache ) {
1022         g_return_val_if_fail( cache != NULL, NULL );
1023         return addrcache_folder_get_address_list( cache, cache->rootFolder );
1024 }
1025
1026 /*
1027 * Return link list of persons for root level folder. Note that the list contains
1028 * references to items and should be g_free() when done. Do *NOT* attempt to used the
1029 * addrcache_free_xxx() functions... this will destroy the address cache data!
1030 * Return: List of items, or NULL if none.
1031 */
1032 GList *addrcache_get_person_list( AddressCache *cache ) {
1033         g_return_val_if_fail( cache != NULL, NULL );
1034         return addritem_folder_get_person_list( cache->rootFolder );
1035 }
1036
1037 /*
1038 * Return link list of group items in root level folder. Note that the list contains
1039 * references to items and should be g_free() when done. Do *NOT* attempt to used the
1040 * addrcache_free_xxx() functions... this will destroy the address cache data!
1041 * Return: List of items, or NULL if none.
1042 */
1043 GList *addrcache_get_group_list( AddressCache *cache ) {
1044         g_return_val_if_fail( cache != NULL, NULL );
1045         return cache->rootFolder->listGroup;
1046 }
1047
1048 /*
1049 * Return link list of folder items in root level folder. Note that the list contains
1050 * references to items and should be g_free() when done. Do *NOT* attempt to used the
1051 * addrcache_free_xxx() functions... this will destroy the address cache data!
1052 * Return: List of items, or NULL if none.
1053 */
1054 GList *addrcache_get_folder_list( AddressCache *cache ) {
1055         g_return_val_if_fail( cache != NULL, NULL );
1056         return cache->rootFolder->listFolder;
1057 }
1058
1059 /*
1060 * Group visitor function.
1061 */
1062 static void addrcache_get_grp_person_vis( gpointer key, gpointer value, gpointer data ) {
1063         AddrItemObject *obj = ( AddrItemObject * ) value;
1064
1065         if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
1066                 AddressCache *cache = data;
1067                 ItemGroup *group = ( ItemGroup * ) obj;
1068                 ItemPerson *person = ( ItemPerson * ) cache->tempList->data;
1069                 GList *node = group->listEMail;
1070                 while( node ) {
1071                         ItemEMail *email = ( ItemEMail * ) node->data;
1072                         if( ADDRITEM_PARENT(email) == ADDRITEM_OBJECT(person) ) {
1073                                 if( ! g_list_find( cache->tempList, group ) ) {
1074                                         cache->tempList = g_list_append( cache->tempList, group );
1075                                 }
1076                         }
1077                         node = g_list_next( node );
1078                 }
1079         }
1080 }
1081
1082 /*
1083 * Return linked list of groups which contain a reference to specified person's email
1084 * address.
1085 */
1086 GList *addrcache_get_group_for_person( AddressCache *cache, ItemPerson *person ) {
1087         GList *list = NULL;
1088
1089         g_return_val_if_fail( cache != NULL, NULL );
1090
1091         cache->tempList = NULL;
1092         cache->tempList = g_list_append( cache->tempList, person );
1093         g_hash_table_foreach( cache->itemHash, addrcache_get_grp_person_vis, cache );
1094         cache->tempList = g_list_remove( cache->tempList, person );
1095         list = cache->tempList;
1096         cache->tempList = NULL;
1097         return list;
1098 }
1099
1100 /*
1101 * Find root folder for specified folder.
1102 * Enter: folder Folder to search.
1103 * Return: root folder, or NULL if not found.
1104 */
1105 ItemFolder *addrcache_find_root_folder( ItemFolder *folder ) {
1106         ItemFolder *item = folder;
1107         gint count = 0;
1108
1109         while( item ) {
1110                 if( item->isRoot ) break;
1111                 if( ++count > ADDRCACHE_MAX_SEARCH_COUNT ) {
1112                         item = NULL;
1113                         break;
1114                 }
1115                 item = ( ItemFolder * ) ADDRITEM_PARENT(folder);
1116         }
1117         return item;
1118 }
1119
1120 /*
1121 * Get all person visitor function.
1122 */
1123 static void addrcache_get_all_persons_vis( gpointer key, gpointer value, gpointer data ) {
1124         AddrItemObject *obj = ( AddrItemObject * ) value;
1125
1126         if( ADDRITEM_TYPE(obj) == ITEMTYPE_PERSON ) {
1127                 AddressCache *cache = data;
1128                 cache->tempList = g_list_append( cache->tempList, obj );
1129         }
1130 }
1131
1132 /*
1133 * Return link list of all persons in address cache.  Note that the list contains
1134 * references to items. Do *NOT* attempt to use the addrcache_free_xxx() functions...
1135 * this will destroy the address cache data!
1136 * Return: List of items, or NULL if none.
1137 */
1138 GList *addrcache_get_all_persons( AddressCache *cache ) {
1139         GList *list = NULL;
1140
1141         g_return_val_if_fail( cache != NULL, NULL );
1142
1143         cache->tempList = NULL;
1144         g_hash_table_foreach( cache->itemHash, addrcache_get_all_persons_vis, cache );
1145         list = cache->tempList;
1146         cache->tempList = NULL;
1147         return list;
1148 }
1149
1150 /*
1151 * Get all groups visitor function.
1152 */
1153 static void addrcache_get_all_groups_vis( gpointer key, gpointer value, gpointer data ) {
1154         AddrItemObject *obj = ( AddrItemObject * ) value;
1155
1156         if( ADDRITEM_TYPE(obj) == ITEMTYPE_GROUP ) {
1157                 AddressCache *cache = data;
1158                 cache->tempList = g_list_append( cache->tempList, obj );
1159         }
1160 }
1161
1162 /*
1163 * Return link list of all groups in address cache.  Note that the list contains
1164 * references to items. Do *NOT* attempt to use the addrcache_free_xxx() functions...
1165 * this will destroy the address cache data!
1166 * Return: List of items, or NULL if none.
1167 */
1168 GList *addrcache_get_all_groups( AddressCache *cache ) {
1169         GList *list = NULL;
1170
1171         g_return_val_if_fail( cache != NULL, NULL );
1172
1173         cache->tempList = NULL;
1174         g_hash_table_foreach( cache->itemHash, addrcache_get_all_groups_vis, cache );
1175         list = cache->tempList;
1176         cache->tempList = NULL;
1177         return list;
1178 }
1179
1180 /*
1181 * Remove folder from cache. Children are re-parented to parent folder.
1182 * param: folder Folder to remove.
1183 * return: Folder, or NULL if not found. Note that object should still be freed.
1184 */
1185 ItemFolder *addrcache_remove_folder( AddressCache *cache, ItemFolder *folder ) {
1186         AddrItemObject *obj = NULL;
1187
1188         g_return_val_if_fail( cache != NULL, NULL );
1189
1190         if( folder ) {
1191                 gchar *uid = ADDRITEM_ID(folder);
1192                 if( uid == NULL || *uid == '\0' ) return NULL;
1193                 obj = ( AddrItemObject * ) g_hash_table_lookup( cache->itemHash, uid );
1194                 if( obj ) {
1195                         ItemFolder *parent = ( ItemFolder * ) ADDRITEM_PARENT(folder);
1196                         GList *node;
1197                         AddrItemObject *aio;
1198                         if( ! parent ) parent = cache->rootFolder;
1199
1200                         /* Re-parent children in folder */
1201                         node = folder->listFolder;
1202                         while( node ) {
1203                                 aio = ( AddrItemObject * ) node->data;
1204                                 parent->listFolder = g_list_append( parent->listFolder, aio );
1205                                 aio->parent = ADDRITEM_OBJECT(parent);
1206                                 node = g_list_next( node );
1207                         }
1208                         node = folder->listPerson;
1209                         while( node ) {
1210                                 aio = ( AddrItemObject * ) node->data;
1211                                 parent->listPerson = g_list_append( parent->listPerson, aio );
1212                                 aio->parent = ADDRITEM_OBJECT(parent);
1213                                 node = g_list_next( node );
1214                         }
1215                         node = folder->listGroup;
1216                         while( node ) {
1217                                 aio = ( AddrItemObject * ) node->data;
1218                                 parent->listGroup = g_list_append( parent->listGroup, aio );
1219                                 aio->parent = ADDRITEM_OBJECT(parent);
1220                                 node = g_list_next( node );
1221                         }
1222
1223                         /* Remove folder from parent's list and hash table */
1224                         parent->listFolder = g_list_remove( parent->listFolder, folder );
1225                         ADDRITEM_PARENT(folder) = NULL;
1226                         g_hash_table_remove( cache->itemHash, uid );
1227                         cache->dirtyFlag = TRUE;
1228                         return folder;
1229                 }
1230         }
1231         return NULL;
1232 }
1233
1234 /*
1235 * Remove folder from cache. Children are deleted.
1236 * param: folder Folder to remove.
1237 * return: Folder, or NULL if not found. Note that object should still be freed.
1238 */
1239 ItemFolder *addrcache_remove_folder_delete( AddressCache *cache, ItemFolder *folder ) {
1240         AddrItemObject *obj = NULL;
1241
1242         g_return_val_if_fail( cache != NULL, NULL );
1243
1244         if( folder ) {
1245                 gchar *uid = ADDRITEM_ID(folder);
1246                 if( uid == NULL || *uid == '\0' ) return NULL;
1247                 obj = ( AddrItemObject * ) g_hash_table_lookup( cache->itemHash, uid );
1248                 if( obj ) {
1249                         ItemFolder *parent = ( ItemFolder * ) ADDRITEM_PARENT(folder);
1250                         if( ! parent ) parent = cache->rootFolder;
1251
1252                         /* Remove groups */
1253                         while( folder->listGroup ) {
1254                                 ItemGroup *item = ( ItemGroup * ) folder->listGroup->data;
1255                                 item = addrcache_remove_group( cache, item );
1256                                 if( item ) {
1257                                         addritem_free_item_group( item );
1258                                         item = NULL;
1259                                 }
1260                         }
1261
1262                         while( folder->listPerson ) {
1263                                 ItemPerson *item = ( ItemPerson * ) folder->listPerson->data;
1264                                 item = addrcache_remove_person( cache, item );
1265                                 if( item ) {
1266                                         addritem_free_item_person( item );
1267                                         item = NULL;
1268                                 }
1269                         }
1270
1271                         /* Recursive deletion of folder */
1272                         while( folder->listFolder ) {
1273                                 ItemFolder *item = ( ItemFolder * ) folder->listFolder->data;
1274                                 item = addrcache_remove_folder_delete( cache, item );
1275                                 if( item ) {
1276                                         addritem_free_item_folder( item );
1277                                         item = NULL;
1278                                 }
1279                         }
1280
1281                         /* Remove folder from parent's list and hash table */
1282                         parent->listFolder = g_list_remove( parent->listFolder, folder );
1283                         ADDRITEM_PARENT(folder) = NULL;
1284                         g_hash_table_remove( cache->itemHash, uid );
1285                         cache->dirtyFlag = TRUE;
1286                         return folder;
1287                 }
1288         }
1289         return NULL;
1290 }
1291
1292 /*
1293 * Add person and address data to cache.
1294 * Enter: cache     Cache.
1295 *        folder    Folder where to add person, or NULL for root folder.
1296 *        name      Common name.
1297 *        address   EMail address.
1298 *        remarks   Remarks.
1299 * Return: Person added. Do not *NOT* to use the addrbook_free_xxx() functions...
1300 * this will destroy the address book data.
1301 */
1302 ItemPerson *addrcache_add_contact( AddressCache *cache, ItemFolder *folder, const gchar *name,
1303                 const gchar *address, const gchar *remarks )
1304 {
1305         ItemPerson *person = NULL;
1306         ItemEMail *email = NULL;
1307         ItemFolder *f = folder;
1308
1309         g_return_val_if_fail( cache != NULL, NULL );
1310
1311         if( ! f ) f = cache->rootFolder;
1312
1313         /* Create person object */
1314         person = addritem_create_item_person();
1315         addritem_person_set_common_name( person, name );
1316         addrcache_id_person( cache, person );
1317         addrcache_folder_add_person( cache, f, person );
1318
1319         /* Create email object */
1320         email = addritem_create_item_email();
1321         addritem_email_set_address( email, address );
1322         addritem_email_set_remarks( email, remarks );
1323         addrcache_id_email( cache, email );
1324         addritem_person_add_email( person, email );
1325         cache->dirtyFlag = TRUE;
1326
1327         return person;
1328 }
1329
1330 /*
1331 * End of Source.
1332 */