diff options
Diffstat (limited to 'libical/src/libicalss/icaldirset.c')
| -rw-r--r-- | libical/src/libicalss/icaldirset.c | 518 |
1 files changed, 233 insertions, 285 deletions
diff --git a/libical/src/libicalss/icaldirset.c b/libical/src/libicalss/icaldirset.c index 4a20fe1978..f5da125459 100644 --- a/libical/src/libicalss/icaldirset.c +++ b/libical/src/libicalss/icaldirset.c @@ -26,10 +26,9 @@ ======================================================================*/ -/** - @file icaldirset.c +/* - @brief icaldirset manages a database of ical components and offers + icaldirset manages a database of ical components and offers interfaces for reading, writting and searching for components. icaldirset groups components in to clusters based on their DTSTAMP @@ -37,13 +36,12 @@ together in a single file. All files in a sotre are kept in a single directory. - The primary interfaces are icaldirset__get_first_component and - icaldirset_get_next_component. These routine iterate through all of - the components in the store, subject to the current gauge. A gauge - is an icalcomponent that is tested against other componets for a - match. If a gauge has been set with icaldirset_select, - icaldirset_first and icaldirset_next will only return componentes - that match the gauge. + The primary interfaces are icaldirset_first and icaldirset_next. These + routine iterate through all of the components in the store, subject + to the current gauge. A gauge is an icalcomponent that is tested + against other componets for a match. If a gauge has been set with + icaldirset_select, icaldirset_first and icaldirset_next will only + return componentes that match the gauge. The Store generated UIDs for all objects that are stored if they do not already have a UID. The UID is the name of the cluster (month & @@ -59,74 +57,64 @@ #include "ical.h" #include "icaldirset.h" +#include "pvl.h" +#include "icalerror.h" +#include "icalparser.h" #include "icaldirset.h" #include "icalfileset.h" #include "icalfilesetimpl.h" -#include "icalcluster.h" #include "icalgauge.h" #include <limits.h> /* For PATH_MAX */ -#ifndef WIN32 -#include <dirent.h> /* for opendir() */ -#include <unistd.h> /* for stat, getpid */ -#include <sys/utsname.h> /* for uname */ -#else -#include <io.h> -#include <process.h> -#endif #include <errno.h> #include <sys/types.h> /* for opendir() */ +#include <dirent.h> /* for opendir() */ #include <sys/stat.h> /* for stat */ +#include <unistd.h> /* for stat, getpid */ #include <time.h> /* for clock() */ #include <stdlib.h> /* for rand(), srand() */ +#include <sys/utsname.h> /* for uname */ #include <string.h> /* for strdup */ #include "icaldirsetimpl.h" -#ifdef WIN32 -#define snprintf _snprintf -#define strcasecmp stricmp - -#define _S_ISTYPE(mode, mask) (((mode) & _S_IFMT) == (mask)) +struct icaldirset_impl* icaldirset_new_impl() +{ + struct icaldirset_impl* impl; -#define S_ISDIR(mode) _S_ISTYPE((mode), _S_IFDIR) -#define S_ISREG(mode) _S_ISTYPE((mode), _S_IFREG) -#endif + if ( ( impl = (struct icaldirset_impl*) + malloc(sizeof(struct icaldirset_impl))) == 0) { + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } -/** Default options used when NULL is passed to icalset_new() **/ -icaldirset_options icaldirset_options_default = {O_RDWR|O_CREAT}; + strcpy(impl->id,ICALDIRSET_ID); + return impl; +} -const char* icaldirset_path(icalset* set) +const char* icaldirset_path(icaldirset* cluster) { - icaldirset *dset = (icaldirset*)set; + struct icaldirset_impl *impl = icaldirset_new_impl(); - return dset->dir; -} + return impl->dir; +} -void icaldirset_mark(icalset* set) +void icaldirset_mark(icaldirset* store) { - icaldirset *dset = (icaldirset*)set; + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; - icalcluster_mark(dset->cluster); + icalfileset_mark(impl->cluster); } -icalerrorenum icaldirset_commit(icalset* set) +icalerrorenum icaldirset_commit(icaldirset* store) { - icaldirset *dset = (icaldirset*)set; - icalset *fileset; - icalfileset_options options = icalfileset_options_default; + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; - options.cluster = dset->cluster; + return icalfileset_commit(impl->cluster); - fileset = icalset_new(ICAL_FILE_SET, icalcluster_key(dset->cluster), &options); - - fileset->commit(fileset); - fileset->free(fileset); - - return ICAL_NO_ERROR; } void icaldirset_lock(const char* dir) @@ -139,22 +127,21 @@ void icaldirset_unlock(const char* dir) } /* Load the contents of the store directory into the store's internal directory list*/ -icalerrorenum icaldirset_read_directory(icaldirset *dset) +icalerrorenum icaldirset_read_directory(struct icaldirset_impl* impl) { - char *str; -#ifndef WIN32 struct dirent *de; DIR* dp; + char *str; - dp = opendir(dset->dir); + dp = opendir(impl->dir); - if (dp == 0) { + if ( dp == 0) { icalerror_set_errno(ICAL_FILE_ERROR); return ICAL_FILE_ERROR; } /* clear contents of directory list */ - while((str = pvl_pop(dset->directory))){ + while((str = pvl_pop(impl->directory))){ free(str); } @@ -169,52 +156,24 @@ icalerrorenum icaldirset_read_directory(icaldirset *dset) continue; } - pvl_push(dset->directory, (void*)strdup(de->d_name)); + pvl_push(impl->directory, (void*)strdup(de->d_name)); } closedir(dp); -#else - struct _finddata_t c_file; - long hFile; - - /* Find first .c file in current directory */ - if( (hFile = _findfirst( "*", &c_file )) == -1L ) { - icalerror_set_errno(ICAL_FILE_ERROR); - return ICAL_FILE_ERROR; - } else { - while((str = pvl_pop(dset->directory))){ - free(str); - } - - /* load all of the cluster names in the directory list */ - do { - /* Remove known directory names '.' and '..'*/ - if (strcmp(c_file.name,".") == 0 || - strcmp(c_file.name,"..") == 0 ){ - continue; - } - - pvl_push(dset->directory, (void*)strdup(c_file.name)); - } - while ( _findnext( hFile, &c_file ) == 0 ); - - _findclose( hFile ); - } - -#endif return ICAL_NO_ERROR; } - -icalset* icaldirset_init(icalset* set, const char* dir, void* options_in) +icaldirset* icaldirset_new(const char* dir) { - icaldirset *dset = (icaldirset*)set; - icaldirset_options *options = options_in; + struct icaldirset_impl *impl = icaldirset_new_impl(); struct stat sbuf; + if (impl == 0){ + return 0; + } + icalerror_check_arg_rz( (dir!=0), "dir"); - icalerror_check_arg_rz( (set!=0), "set"); if (stat(dir,&sbuf) != 0){ icalerror_set_errno(ICAL_FILE_ERROR); @@ -229,83 +188,68 @@ icalset* icaldirset_init(icalset* set, const char* dir, void* options_in) icaldirset_lock(dir); - dset->dir = (char*)strdup(dir); - dset->options = *options; - dset->directory = pvl_newlist(); - dset->directory_iterator = 0; - dset->gauge = 0; - dset->first_component = 0; - dset->cluster = 0; - - return set; -} - -icalset* icaldirset_new(const char* dir) -{ - return icalset_new(ICAL_DIR_SET, dir, &icaldirset_options_default); -} - - -icalset* icaldirset_new_reader(const char* dir) -{ - icaldirset_options reader_options = icaldirset_options_default; - - reader_options.flags = O_RDONLY; - - return icalset_new(ICAL_DIR_SET, dir, &reader_options); -} + impl = icaldirset_new_impl(); + if (impl ==0){ + icalerror_set_errno(ICAL_NEWFAILED_ERROR); + return 0; + } -icalset* icaldirset_new_writer(const char* dir) -{ - icaldirset_options writer_options = icaldirset_options_default; + impl->directory = pvl_newlist(); + impl->directory_iterator = 0; + impl->dir = (char*)strdup(dir); + impl->gauge = 0; + impl->first_component = 0; + impl->cluster = 0; - writer_options.flags = O_RDWR|O_CREAT; + icaldirset_read_directory(impl); - return icalset_new(ICAL_DIR_SET, dir, &writer_options); + return (icaldirset*) impl; } - -void icaldirset_free(icalset* s) +void icaldirset_free(icaldirset* s) { - icaldirset *dset = (icaldirset*)s; + struct icaldirset_impl *impl = (struct icaldirset_impl*)s; char* str; - icaldirset_unlock(dset->dir); + icaldirset_unlock(impl->dir); - if(dset->dir !=0){ - free(dset->dir); - dset->dir = 0; + if(impl->dir !=0){ + free(impl->dir); } - if(dset->gauge !=0){ - icalgauge_free(dset->gauge); - dset->gauge = 0; + if(impl->gauge !=0){ + icalcomponent_free(impl->gauge); } - if(dset->cluster !=0){ - icalcluster_free(dset->cluster); + if(impl->cluster !=0){ + icalfileset_free(impl->cluster); } - while(dset->directory !=0 && (str=pvl_pop(dset->directory)) != 0){ + while(impl->directory !=0 && (str=pvl_pop(impl->directory)) != 0){ free(str); } - if(dset->directory != 0){ - pvl_free(dset->directory); - dset->directory = 0; + if(impl->directory != 0){ + pvl_free(impl->directory); } - dset->directory_iterator = 0; - dset->first_component = 0; -} + impl->directory = 0; + impl->directory_iterator = 0; + impl->dir = 0; + impl->gauge = 0; + impl->first_component = 0; + free(impl); + +} /* icaldirset_next_uid_number updates a serial number in the Store directory in a file called SEQUENCE */ -int icaldirset_next_uid_number(icaldirset* dset) +int icaldirset_next_uid_number(icaldirset* store) { + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; char sequence = 0; char temp[128]; char filename[ICAL_PATH_MAX]; @@ -313,9 +257,9 @@ int icaldirset_next_uid_number(icaldirset* dset) FILE *f; struct stat sbuf; - icalerror_check_arg_rz( (dset!=0), "dset"); + icalerror_check_arg_rz( (store!=0), "store"); - sprintf(filename,"%s/%s",dset->dir,"SEQUENCE"); + sprintf(filename,"%s/%s",impl->dir,"SEQUENCE"); /* Create the file if it does not exist.*/ if (stat(filename,&sbuf) == -1 || !S_ISREG(sbuf.st_mode)){ @@ -328,6 +272,7 @@ int icaldirset_next_uid_number(icaldirset* dset) icalerror_warn("Can't create SEQUENCE file in icaldirset_next_uid_number"); return 0; } + } if ( (f = fopen(filename,"r+")) != 0){ @@ -353,85 +298,85 @@ int icaldirset_next_uid_number(icaldirset* dset) icalerror_warn("Can't create SEQUENCE file in icaldirset_next_uid_number"); return 0; } + } -icalerrorenum icaldirset_next_cluster(icaldirset* dset) +icalerrorenum icaldirset_next_cluster(icaldirset* store) { + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; char path[ICAL_PATH_MAX]; - if (dset->directory_iterator == 0){ + if (impl->directory_iterator == 0){ icalerror_set_errno(ICAL_INTERNAL_ERROR); return ICAL_INTERNAL_ERROR; } - dset->directory_iterator = pvl_next(dset->directory_iterator); + impl->directory_iterator = pvl_next(impl->directory_iterator); - if (dset->directory_iterator == 0){ + if (impl->directory_iterator == 0){ /* There are no more clusters */ - if(dset->cluster != 0){ - icalcluster_free(dset->cluster); - dset->cluster = 0; + if(impl->cluster != 0){ + icalfileset_free(impl->cluster); + impl->cluster = 0; } return ICAL_NO_ERROR; } - sprintf(path,"%s/%s", dset->dir,(char*)pvl_data(dset->directory_iterator)); + sprintf(path,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator)); + + icalfileset_free(impl->cluster); - icalcluster_free(dset->cluster); - dset->cluster = icalfileset_produce_icalcluster(path); + impl->cluster = icalfileset_new(path); return icalerrno; } -static void icaldirset_add_uid(icalcomponent* comp) +void icaldirset_add_uid(icaldirset* store, icaldirset* comp) { char uidstring[ICAL_PATH_MAX]; icalproperty *uid; -#ifndef WIN32 struct utsname unamebuf; -#endif + icalerror_check_arg_rv( (store!=0), "store"); icalerror_check_arg_rv( (comp!=0), "comp"); uid = icalcomponent_get_first_property(comp,ICAL_UID_PROPERTY); if (uid == 0) { -#ifndef WIN32 uname(&unamebuf); sprintf(uidstring,"%d-%s",(int)getpid(),unamebuf.nodename); -#else - sprintf(uidstring,"%d-%s",(int)getpid(),"WINDOWS"); /* FIX: There must be an easy get the system name */ -#endif uid = icalproperty_new_uid(uidstring); icalcomponent_add_property(comp,uid); } else { + strcpy(uidstring,icalproperty_get_uid(uid)); } } -/** - This assumes that the top level component is a VCALENDAR, and there +/* This assumes that the top level component is a VCALENDAR, and there is an inner component of type VEVENT, VTODO or VJOURNAL. The inner - component must have a DSTAMP property -*/ + component must have a DTAMP property */ -icalerrorenum icaldirset_add_component(icalset* set, icalcomponent* comp) +icalerrorenum icaldirset_add_component(icaldirset* store, icaldirset* comp) { + struct icaldirset_impl *impl; char clustername[ICAL_PATH_MAX]; - icalproperty *dt = 0; + icalproperty *dt; icalvalue *v; struct icaltimetype tm; icalerrorenum error = ICAL_NO_ERROR; icalcomponent *inner; - icaldirset *dset = (icaldirset*) set; - icalerror_check_arg_rz( (dset!=0), "dset"); + impl = (struct icaldirset_impl*)store; + icalerror_check_arg_rz( (store!=0), "store"); icalerror_check_arg_rz( (comp!=0), "comp"); - icaldirset_add_uid(comp); + errno = 0; + + icaldirset_add_uid(store,comp); /* Determine which cluster this object belongs in. This is a HACK */ @@ -441,44 +386,52 @@ icalerrorenum icaldirset_add_component(icalset* set, icalcomponent* comp) dt = icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY); - if (dt != 0) + if (dt != 0){ break; } + } + + if (dt == 0){ - if (dt == 0) { for(inner = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT); inner != 0; inner = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){ dt = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY); - if (dt != 0) + if (dt != 0){ break; } } + } + if (dt == 0){ + + icalerror_warn("The component does not have a DTSTAMP or DTSTART property, so it cannot be added to the store"); icalerror_set_errno(ICAL_BADARG_ERROR); return ICAL_BADARG_ERROR; } v = icalproperty_get_value(dt); + tm = icalvalue_get_datetime(v); - snprintf(clustername,ICAL_PATH_MAX,"%s/%04d%02d",dset->dir, tm.year, tm.month); + snprintf(clustername,ICAL_PATH_MAX,"%s/%04d%02d",impl->dir,tm.year,tm.month); /* Load the cluster and insert the object */ - if(dset->cluster != 0 && - strcmp(clustername,icalcluster_key(dset->cluster)) != 0 ){ - icalcluster_free(dset->cluster); - dset->cluster = 0; + + if(impl->cluster != 0 && + strcmp(clustername,icalfileset_path(impl->cluster)) != 0 ){ + icalfileset_free(impl->cluster); + impl->cluster = 0; } - if (dset->cluster == 0){ - dset->cluster = icalfileset_produce_icalcluster(clustername); + if (impl->cluster == 0){ + impl->cluster = icalfileset_new(clustername); - if (dset->cluster == 0){ + if (impl->cluster == 0){ error = icalerrno; } } @@ -489,31 +442,33 @@ icalerrorenum icaldirset_add_component(icalset* set, icalcomponent* comp) } /* Add the component to the cluster */ - icalcluster_add_component(dset->cluster,comp); + + icalfileset_add_component(impl->cluster,comp); - /* icalcluster_mark(impl->cluster); */ + icalfileset_mark(impl->cluster); return ICAL_NO_ERROR; } -/** - Remove a component in the current cluster. HACK. This routine is a +/* Remove a component in the current cluster. HACK. This routine is a "friend" of icalfileset, and breaks its encapsulation. It was either do it this way, or add several layers of interfaces that had - no other use. - */ - -icalerrorenum icaldirset_remove_component(icalset* set, icalcomponent* comp) + no other use. */ +icalerrorenum icaldirset_remove_component(icaldirset* store, icaldirset* comp) { - icaldirset *dset = (icaldirset*)set; - icalcomponent *filecomp = icalcluster_get_component(dset->cluster); + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; + + struct icalfileset_impl *filesetimpl = + (struct icalfileset_impl*)impl->cluster; + + icalcomponent *filecomp = filesetimpl->cluster; icalcompiter i; int found = 0; - icalerror_check_arg_re((set!=0),"set",ICAL_BADARG_ERROR); + icalerror_check_arg_re((store!=0),"store",ICAL_BADARG_ERROR); icalerror_check_arg_re((comp!=0),"comp",ICAL_BADARG_ERROR); - icalerror_check_arg_re((dset->cluster!=0),"Cluster pointer",ICAL_USAGE_ERROR); + icalerror_check_arg_re((impl->cluster!=0),"Cluster pointer",ICAL_USAGE_ERROR); for(i = icalcomponent_begin_component(filecomp,ICAL_ANY_COMPONENT); icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){ @@ -532,16 +487,17 @@ icalerrorenum icaldirset_remove_component(icalset* set, icalcomponent* comp) return ICAL_USAGE_ERROR; } - icalcluster_remove_component(dset->cluster,comp); + icalfileset_remove_component(impl->cluster,comp); - /* icalcluster_mark(impl->cluster); */ + icalfileset_mark(impl->cluster); /* If the removal emptied the fileset, get the next fileset */ - if( icalcluster_count_components(dset->cluster,ICAL_ANY_COMPONENT)==0){ - icalerrorenum error = icaldirset_next_cluster(dset); + if( icalfileset_count_components(impl->cluster,ICAL_ANY_COMPONENT)==0){ + + icalerrorenum error = icaldirset_next_cluster(store); - if(dset->cluster != 0 && error == ICAL_NO_ERROR){ - icalcluster_get_first_component(dset->cluster); + if(impl->cluster != 0 && error == ICAL_NO_ERROR){ + icalfileset_get_first_component(impl->cluster); } else { /* HACK. Not strictly correct for impl->cluster==0 */ return error; @@ -555,84 +511,95 @@ icalerrorenum icaldirset_remove_component(icalset* set, icalcomponent* comp) -int icaldirset_count_components(icalset* store, +int icaldirset_count_components(icaldirset* store, icalcomponent_kind kind) { /* HACK, not implemented */ + assert(0); return 0; } -icalcomponent* icaldirset_fetch_match(icalset* set, icalcomponent *c) +icalcomponent* icaldirset_fetch_match(icaldirset* set, icalcomponent *c) { fprintf(stderr," icaldirset_fetch_match is not implemented\n"); assert(0); - return 0; } -icalcomponent* icaldirset_fetch(icalset* set, const char* uid) +icalcomponent* icaldirset_fetch(icaldirset* store, const char* uid) { - icaldirset *dset = (icaldirset*)set; - icalgauge *gauge; - icalgauge *old_gauge; + icalcomponent *gauge; + icalcomponent *old_gauge; icalcomponent *c; - char sql[256]; + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; - icalerror_check_arg_rz( (set!=0), "set"); + icalerror_check_arg_rz( (store!=0), "store"); icalerror_check_arg_rz( (uid!=0), "uid"); - snprintf(sql, 256, "SELECT * FROM VEVENT WHERE UID = \"%s\"", uid); - - gauge = icalgauge_new_from_sql(sql, 0); + gauge = + icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_uid( + uid, + icalparameter_new_xliccomparetype( + ICAL_XLICCOMPARETYPE_EQUAL), + 0), + 0), + 0); - old_gauge = dset->gauge; - dset->gauge = gauge; + old_gauge = impl->gauge; + impl->gauge = gauge; - c= icaldirset_get_first_component(set); + c= icaldirset_get_first_component(store); - dset->gauge = old_gauge; + impl->gauge = old_gauge; - icalgauge_free(gauge); + icalcomponent_free(gauge); return c; } -int icaldirset_has_uid(icalset* set, const char* uid) +int icaldirset_has_uid(icaldirset* store, const char* uid) { icalcomponent *c; - icalerror_check_arg_rz( (set!=0), "set"); + icalerror_check_arg_rz( (store!=0), "store"); icalerror_check_arg_rz( (uid!=0), "uid"); /* HACK. This is a temporary implementation. _has_uid should use a database, and _fetch should use _has_uid, not the other way around */ - c = icaldirset_fetch(set,uid); + c = icaldirset_fetch(store,uid); return c!=0; } -icalerrorenum icaldirset_select(icalset* set, icalgauge* gauge) -{ - icaldirset *dset = (icaldirset*)set; +icalerrorenum icaldirset_select(icaldirset* store, icalcomponent* gauge) + { + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; - icalerror_check_arg_re( (set!=0), "set",ICAL_BADARG_ERROR); + icalerror_check_arg_re( (store!=0), "store",ICAL_BADARG_ERROR); icalerror_check_arg_re( (gauge!=0), "gauge",ICAL_BADARG_ERROR); - dset->gauge = gauge; + if (!icalcomponent_is_valid(gauge)){ + return ICAL_BADARG_ERROR; + } + + impl->gauge = gauge; return ICAL_NO_ERROR; } -icalerrorenum icaldirset_modify(icalset* set, - icalcomponent *old, +icalerrorenum icaldirset_modify(icaldirset* store, icalcomponent *old, icalcomponent *new) { assert(0); @@ -641,7 +608,7 @@ icalerrorenum icaldirset_modify(icalset* set, } -void icaldirset_clear(icalset* set) +void icaldirset_clear(icaldirset* store) { assert(0); @@ -649,58 +616,53 @@ void icaldirset_clear(icalset* set) /* HACK, not implemented */ } -icalcomponent* icaldirset_get_current_component(icalset* set) +icalcomponent* icaldirset_get_current_component(icaldirset* store) { - icaldirset *dset = (icaldirset*)set; + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; - if (dset->cluster == 0){ - icaldirset_get_first_component(set); - } - if(dset->cluster == 0){ - return 0; + if(impl->cluster == 0){ + icaldirset_get_first_component(store); } - return icalcluster_get_current_component(dset->cluster); + return icalfileset_get_current_component(impl->cluster); + } -icalcomponent* icaldirset_get_first_component(icalset* set) +icalcomponent* icaldirset_get_first_component(icaldirset* store) { - icaldirset *dset = (icaldirset*)set; - + struct icaldirset_impl *impl = (struct icaldirset_impl*)store; icalerrorenum error; char path[ICAL_PATH_MAX]; - error = icaldirset_read_directory(dset); + error = icaldirset_read_directory(impl); if (error != ICAL_NO_ERROR){ icalerror_set_errno(error); return 0; } - dset->directory_iterator = pvl_head(dset->directory); + impl->directory_iterator = pvl_head(impl->directory); - if (dset->directory_iterator == 0){ + if (impl->directory_iterator == 0){ icalerror_set_errno(error); return 0; } - snprintf(path,ICAL_PATH_MAX,"%s/%s", - dset->dir, - (char*)pvl_data(dset->directory_iterator)); + snprintf(path,ICAL_PATH_MAX,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator)); /* If the next cluster we need is different than the current cluster, delete the current one and get a new one */ - if(dset->cluster != 0 && strcmp(path,icalcluster_key(dset->cluster)) != 0 ){ - icalcluster_free(dset->cluster); - dset->cluster = 0; + if(impl->cluster != 0 && strcmp(path,icalfileset_path(impl->cluster)) != 0 ){ + icalfileset_free(impl->cluster); + impl->cluster = 0; } - if (dset->cluster == 0){ - dset->cluster = icalfileset_produce_icalcluster(path); + if (impl->cluster == 0){ + impl->cluster = icalfileset_new(path); - if (dset->cluster == 0){ + if (impl->cluster == 0){ error = icalerrno; } } @@ -710,22 +672,23 @@ icalcomponent* icaldirset_get_first_component(icalset* set) return 0; } - dset->first_component = 1; + impl->first_component = 1; - return icaldirset_get_next_component(set); + return icaldirset_get_next_component(store); } - -icalcomponent* icaldirset_get_next_component(icalset* set) +icalcomponent* icaldirset_get_next_component(icaldirset* store) { - icaldirset *dset = (icaldirset*)set; + struct icaldirset_impl *impl; icalcomponent *c; icalerrorenum error; - icalerror_check_arg_rz( (set!=0), "set"); + icalerror_check_arg_rz( (store!=0), "store"); + + impl = (struct icaldirset_impl*)store; + if(impl->cluster == 0){ - if(dset->cluster == 0){ icalerror_warn("icaldirset_get_next_component called with a NULL cluster (Caller must call icaldirset_get_first_component first"); icalerror_set_errno(ICAL_USAGE_ERROR); return 0; @@ -733,26 +696,30 @@ icalcomponent* icaldirset_get_next_component(icalset* set) } /* Set the component iterator for the following for loop */ - if (dset->first_component == 1){ - icalcluster_get_first_component(dset->cluster); - dset->first_component = 0; + if (impl->first_component == 1){ + icalfileset_get_first_component(impl->cluster); + impl->first_component = 0; } else { - icalcluster_get_next_component(dset->cluster); + icalfileset_get_next_component(impl->cluster); } + while(1){ /* Iterate through all of the objects in the cluster*/ - for( c = icalcluster_get_current_component(dset->cluster); + for( c = icalfileset_get_current_component(impl->cluster); c != 0; - c = icalcluster_get_next_component(dset->cluster)){ + c = icalfileset_get_next_component(impl->cluster)){ /* If there is a gauge defined and the component does not pass the gauge, skip the rest of the loop */ - if (dset->gauge != 0 && icalgauge_compare(dset->gauge,c) == 0){ +#if 0 /* HACK */ + if (impl->gauge != 0 && icalgauge_test(c,impl->gauge) == 0){ continue; } - +#else + assert(0); /* icalgauge_test needs to be fixed */ +#endif /* Either there is no gauge, or the component passed the gauge, so return it*/ @@ -762,13 +729,13 @@ icalcomponent* icaldirset_get_next_component(icalset* set) /* Fell through the loop, so the component we want is not in this cluster. Load a new cluster and try again.*/ - error = icaldirset_next_cluster(dset); + error = icaldirset_next_cluster(store); - if(dset->cluster == 0 || error != ICAL_NO_ERROR){ + if(impl->cluster == 0 || error != ICAL_NO_ERROR){ /* No more clusters */ return 0; } else { - c = icalcluster_get_first_component(dset->cluster); + c = icalfileset_get_first_component(impl->cluster); return c; } @@ -778,28 +745,9 @@ icalcomponent* icaldirset_get_next_component(icalset* set) return 0; /* Should never get here */ } -icalsetiter icaldirset_begin_component(icalset* set, icalcomponent_kind kind, icalgauge* gauge) -{ - icalsetiter itr = icalsetiter_null; - icaldirset *fset = (icaldirset*) set; - - icalerror_check_arg_re((fset!=0), "set", icalsetiter_null); + - itr.iter.kind = kind; - itr.gauge = gauge; - /* TO BE IMPLEMENTED */ - return icalsetiter_null; -} -icalcomponent* icaldirsetiter_to_next(icalset* set, icalsetiter* i) -{ - /* TO BE IMPLEMENTED */ - return NULL; -} -icalcomponent* icaldirsetiter_to_prior(icalset* set, icalsetiter* i) -{ - /* TO BE IMPLEMENTED */ - return NULL; -} + |