1 files changed, 318 insertions, 192 deletions

diff --git a/libical/src/libicalss/icalset.c b/libical/src/libicalss/icalset.c
index 2120609..0ad2269 100644
--- a/libical/src/libicalss/icalset.c
+++ b/libical/src/libicalss/icalset.c
@@ -41,33 +41,26 @@
 #include "icaldirset.h"
 #include "icaldirsetimpl.h"
 #include <stdlib.h>
-/*#include "icalheapset.h"*/
-/*#include "icalmysqlset.h"*/
-
-#define ICALSET_ID "set "
-
-struct icalset_fp {
-        void (*free)(icalset* set);
-        const char* (*path)(icalset* set);
-        void (*mark)(icalset* set);
-        icalerrorenum (*commit)(icalset* set); 
-        icalerrorenum (*add_component)(icalset* set, icalcomponent* comp);
-        icalerrorenum (*remove_component)(icalset* set, icalcomponent* comp);
-        int (*count_components)(icalset* set,
-                             icalcomponent_kind kind);
-        icalerrorenum (*select)(icalset* set, icalcomponent* gauge);
-        void (*clear)(icalset* set);
-        icalcomponent* (*fetch)(icalset* set, const char* uid);
-        icalcomponent* (*fetch_match)(icalset* set, icalcomponent *comp);
-        int (*has_uid)(icalset* set, const char* uid);
-        icalerrorenum (*modify)(icalset* set, icalcomponent *old,
-                                     icalcomponent *new);
-                icalcomponent* (*get_current_component)(icalset* set);
-        icalcomponent* (*get_first_component)(icalset* set);
-        icalcomponent* (*get_next_component)(icalset* set);
-};
-
-struct icalset_fp icalset_dirset_fp = {
+#include <string.h>
+#include <errno.h>
+
+#ifdef WITH_BDB4
+#include "icalbdbset.h"
+#include "icalbdbsetimpl.h"
+#endif
+
+/* #define _DLOPEN_TEST */
+#ifdef _DLOPEN_TEST
+#include <sys/types.h>
+#include <dlfcn.h>
+#include <dirent.h>
+#endif
+
+static icalset icalset_dirset_init = {
+    ICAL_DIR_SET,
+    sizeof(icaldirset),
+    NULL,
+    icaldirset_init,
     icaldirset_free,
     icaldirset_path,
     icaldirset_mark,
@@ -83,11 +76,18 @@ struct icalset_fp icalset_dirset_fp = {
     icaldirset_modify,
     icaldirset_get_current_component,
     icaldirset_get_first_component,
-    icaldirset_get_next_component
+    icaldirset_get_next_component,
+    icaldirset_begin_component,
+    icaldirsetiter_to_next,
+    icaldirsetiter_to_prior
 };
 
 
-struct icalset_fp icalset_fileset_fp = {
+static icalset icalset_fileset_init = {
+    ICAL_FILE_SET,
+    sizeof(icalfileset),
+    NULL,
+    icalfileset_init,
     icalfileset_free,
     icalfileset_path,
     icalfileset_mark,
@@ -103,265 +103,391 @@ struct icalset_fp icalset_fileset_fp = {
     icalfileset_modify,
     icalfileset_get_current_component,
     icalfileset_get_first_component,
-    icalfileset_get_next_component
+    icalfileset_get_next_component,
+    icalfileset_begin_component,
+    icalfilesetiter_to_next,
+    NULL
 };
 
-struct icalset_impl {
+#ifdef WITH_BDB4
+static icalset icalset_bdbset_init = {
+    ICAL_BDB_SET,
+    sizeof(icalbdbset),
+    NULL,
+    icalbdbset_init,
+    icalbdbset_free,
+    icalbdbset_path,
+    icalbdbset_mark,
+    icalbdbset_commit,
+    icalbdbset_add_component,
+    icalbdbset_remove_component,
+    icalbdbset_count_components,
+    icalbdbset_select,
+    icalbdbset_clear,
+    icalbdbset_fetch,
+    icalbdbset_fetch_match,
+    icalbdbset_has_uid,
+    icalbdbset_modify,
+    icalbdbset_get_current_component,
+    icalbdbset_get_first_component,
+    icalbdbset_get_next_component,
+    icalbdbset_begin_component,
+    icalbdbsetiter_to_next,
+    NULL 
+};
+#endif
 
-        char id[5]; /* "set " */
+#ifdef _DLOPEN_TEST
+        static inticalset_init_done = 0;
+static pvl_list icalset_kinds = 0;
 
-        void *derived_impl;
-        struct icalset_fp *fp;
-};
+typedef icalset *(*fptr)(void);
 
-/* Figure out what was actually passed in as the set. This could be a
-   set or and of the derived types such as dirset or fileset. Note
-   this routine returns a value, not a reference, to avoid memory
-   leaks in the methods */
-struct icalset_impl icalset_get_impl(icalset* set)
-{
-    struct icalset_impl  impl;
-
-    memset(&impl,0,sizeof(impl));
-    icalerror_check_arg_re( (set!=0),"set",impl);
-
-    if(strcmp((char*)set,ICALSET_ID)==0) {
-        /* It is actually a set, so just sent the reference back out. */
-        return *(struct icalset_impl*)set;
-    } else if(strcmp((char*)set,ICALFILESET_ID)==0) {
-        /* Make a new set from the fileset */
-        impl.fp = &icalset_fileset_fp;
-        impl.derived_impl = set;
-        strcpy(impl.id,ICALFILESET_ID);/* HACK. Is this necessary? */
-        return impl;
-    } else if(strcmp((char*)set,ICALDIRSET_ID)==0) {
-        /* Make a new set from the dirset */
-        impl.fp = &icalset_dirset_fp;
-        impl.derived_impl = set;
-        strcpy(impl.id,ICALDIRSET_ID);/* HACK. Is this necessary? */
-        return impl;
-    } else {
-        /* The type of set is unknown, so throw an error */
-        icalerror_assert((0),"Unknown set type");
-        return impl;
-    }
-}
-
-
-struct icalset_impl* icalset_new_impl()
-{
+/**
+ * Try to load the file and register any icalset found within.
+ */
+static int load(const char *file) {
     
-    struct icalset_impl* impl;
+        void           *modh;
+        fptr            inith;
+                icalset       *icalset_init_ptr;
 
-    if ( ( impl = (struct icalset_impl*)
-           malloc(sizeof(struct icalset_impl))) == 0) {
-        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        if ((modh = dlopen(file, RTLD_NOW)) == 0) {
+                perror("dlopen");
         return 0;
     }
 
-    strcpy(impl->id,ICALSET_ID);
+        if ((inith = (fptr)dlsym(modh, "InitModule")) == 0) {
+                perror("dlsym");
+                return 0;
+        }
 
-    impl->derived_impl = 0;
-    impl->fp = 0;
+        while ((icalset_init_ptr = ((inith)())) != 0) {
+                pvl_push(icalset_kinds, &icalset_init_ptr);
+        }
 
-    return impl;
+        return 1;
 }
 
-struct icalset_impl* icalset_new_file_from_ref(icalfileset *fset)
-{
-    struct icalset_impl *impl = icalset_new_impl();
+/**
+ * Look in the given directory for files called mod_*.o and try to
+ * load them.
+ */
+int icalset_loaddir(const char *path) {
+        DIR             *d;
+        struct dirent   *dp;
+        char            buf[PATH_MAX],
+                       *bufptr;
+        int             tot = 0;
+
+        strcpy(buf, path);
+        bufptr = buf + strlen(buf);
 
-    icalerror_check_arg_rz( (fset!=0),"fset");
+        if (*(bufptr-1) != '/')
+                *bufptr++ = '/';
 
-    if(impl == 0){
-        free(impl);
+        if ((d = opendir(path)) == 0) {
+                perror("opendir");
         return 0;
     }
 
-    impl->derived_impl = fset;
+        while ((dp = readdir(d)) != 0) {
+                if (strncmp(dp->d_name, "mod_", 4)) continue;
 
-    if (impl->derived_impl == 0){
-        free(impl);
-        return 0;
-    }
+                strcpy(bufptr, dp->d_name);
 
-    impl->fp = &icalset_fileset_fp;
+                load(buf);
+                tot++;
+        }
+        (void)closedir(d);
 
-    return (struct icalset_impl*)impl;
+        return 1;
 }
 
-icalset* icalset_new_file(const char* path)
-{
-    icalfileset *fset = icalfileset_new(path);
+int icalset_register_class(icalset *set);
 
-    if(fset == 0){
-        return 0;
+static void icalset_init(void) {
+    assert(icalset_kinds == 0);
+    icalset_kinds = pvl_newlist();
+
+    pvl_push(icalset_kinds, &icalset_fileset_init);
+    pvl_push(icalset_kinds, &icalset_dirset_init);
+#ifdef WITH_BDB4
+    pvl_push(icalset_kinds, &icalset_bdb4set_init);
+#endif
+
+#ifdef EXT_PATH
+    icalset_loaddir(EXT_PATH);
+#endif
+
+    icalset_init_done++;
     }
 
-    return (icalset*)icalset_new_file_from_ref(fset);
+int icalset_register_class(icalset *set) {
+
+    if (!icalset_init_done)
+        icalset_init();
+
+    pvl_push(icalset_kinds, set);
+    return 1;
 }
 
-icalset* icalset_new_dir_from_ref(icaldirset *dset)
-{
+#endif
 
-    struct icalset_impl *impl = icalset_new_impl();
+icalset* icalset_new(icalset_kind kind, const char* dsn, void* options) {
+  icalset *data = NULL;
+  icalset *ret = NULL;
 
-    icalerror_check_arg_rz( (dset!=0),"dset");
+#ifdef _DLOPEN_TEST
+            pvl_eleme;
+    icalset    *impl;
 
-    if(impl == 0){
-        return 0;
-    }
+    if (!icalset_init_done)
+        icalset_init();
 
-    impl->derived_impl = dset;
+    for(e = pvl_head(icalset_kinds); e!=0; e = pvl_next(e)) {
+        impl = (icalset*)pvl_data(e);
+        if (impl->kind == kind)
+            break;
+    }
+    if (e == 0) {
+        icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+        return(NULL);
+    }
 
-    if (impl->derived_impl == 0){
-        free(impl);
+    data = (icalset*)malloc(impl->size);
+    if (data == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        errno = ENOMEM;
         return 0;
     }
 
-    impl->fp = &icalset_dirset_fp;
+    /* The first member of the derived class must be an icalset. */
+    memset(data,0,impl->size);
+    /* *data = *impl; */
+    memcpy(data, impl, sizeof(icalset));
 
-    return impl;
+    data->dsn     = strdup(dsn);
+#else
+  switch(kind) {
+  case ICAL_FILE_SET:
+    data = (icalset*) malloc(sizeof(icalfileset));
+    if (data == 0) {
+              icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        errno = ENOMEM;
+        return 0;
+    }
+    memset(data,0,sizeof(icalfileset));
+    *data = icalset_fileset_init;
+    break;
+  case ICAL_DIR_SET:
+    data = (icalset*) malloc(sizeof(icaldirset));
+    if (data == 0) {
+              icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        errno = ENOMEM;
+        return 0;
+    }
+    memset(data,0,sizeof(icaldirset));
+    *data = icalset_dirset_init;
+    break;
+#ifdef WITH_BDB4
+  case ICAL_BDB_SET:
+    data = (icalset*) malloc(sizeof(icalbdbset));
+    if (data == 0) {
+              icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        errno = ENOMEM;
+        return 0;
 }
+    memset(data,0,sizeof(icalbdbset));
+    *data = icalset_bdbset_init;
+    break;
+#endif
 
-icalset* icalset_new_dir(const char* path)
-{
-    icaldirset *dset = icaldirset_new(path);
+  default:
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    /** unimplemented **/
+    return(NULL);
+  }
 
-    if(dset == 0){
+  if ( data == 0) {
+    icalerror_set_errno(ICAL_NEWFAILED_ERROR);
         return 0;
     }
+  data->kind    = kind;
+  data->dsn     = strdup(dsn);
+#endif
+
+  /** call the implementation specific initializer **/
+  if ((ret = data->init(data, dsn, options)) == NULL)
+    icalset_free(data);
 
-    return icalset_new_dir_from_ref(dset);
+  return ret;
 }
 
-icalset* icalset_new_heap(void)
+icalset* icalset_new_file(const char* path)
 {
-    struct icalset_impl *impl = icalset_new_impl();
-
+  return icalset_new(ICAL_FILE_SET, path, NULL);
+}
 
-    if(impl == 0){
-        free(impl);
-        return 0;
+icalset* icalset_new_file_writer(const char* path)
+{
+  return icalfileset_new_writer(path);
     }
 
-    return 0;
+icalset* icalset_new_file_reader(const char* path)
+{
+  return icalfileset_new_reader(path);
 }
 
-icalset* icalset_new_mysql(const char* path)
+
+icalset* icalset_new_dir(const char* path)
 {
-    struct icalset_impl *impl = icalset_new_impl();
+  return icalset_new(ICAL_DIR_SET, path, NULL);
+}
 
-    if(impl == 0){
-        free(impl);
-        return 0;
+icalset* icalset_new_dir_writer(const char* path)
+{
+  return icaldirset_new_writer(path);
     }
 
-    return 0;
+icalset* icalset_new_dir_reader(const char* path)
+{
+  return icaldirset_new_reader(path);
 }
 
+
+
+/* Functions for built-in methods */
+
+/**
+ *  free memory associated with this icalset
+ *  automatically calls the implementation specific free routine
+ */
+
 void icalset_free(icalset* set)
 {
-    struct icalset_impl impl = icalset_get_impl(set);
-    (*(impl.fp->free))(impl.derived_impl);
+  if (set->free)
+    set->free(set);
+
+  if (set->dsn)
+    free(set->dsn);
 
-   if(strcmp((char*)set,ICALSET_ID)) {    
        free(set);
    }
+
+
+const char* icalset_path(icalset* set) {
+    return set->path(set);
 }
 
-const char* icalset_path(icalset* set)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->path))(impl.derived_impl);
+void icalset_mark(icalset* set) {
+    set->mark(set);
 }
 
-void icalset_mark(icalset* set)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    (*(impl.fp->mark))(impl.derived_impl);
+icalerrorenum icalset_commit(icalset* set) {
+    return set->commit(set);
 }
 
-icalerrorenum icalset_commit(icalset* set)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->commit))(impl.derived_impl);
+icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp) {
+    return set->add_component(set,comp);
 }
 
-icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->add_component))(impl.derived_impl,comp);
+icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp) {
+    return set->remove_component(set,comp);
 }
 
-icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->remove_component))(impl.derived_impl,comp);
+int icalset_count_components(icalset* set,icalcomponent_kind kind) {
+    return set->count_components(set,kind);
 }
 
-int icalset_count_components(icalset* set,icalcomponent_kind kind)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->count_components))(impl.derived_impl,kind);
+icalerrorenum icalset_select(icalset* set, icalgauge* gauge) {
+    return set->select(set, gauge);
 }
 
-icalerrorenum icalset_select(icalset* set, icalcomponent* gauge)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->select))(impl.derived_impl,gauge);
+void icalset_clear(icalset* set) {
+    set->clear(set);
 }
 
-void icalset_clear(icalset* set)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    (*(impl.fp->clear))(impl.derived_impl);
+icalcomponent* icalset_fetch(icalset* set, const char* uid) {
+    return set->fetch(set, uid);
 }
 
-icalcomponent* icalset_fetch(icalset* set, const char* uid)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->fetch))(impl.derived_impl,uid);
+icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *comp) {
+    return set->fetch_match(set, comp);
 }
 
-icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *comp)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->fetch_match))(impl.derived_impl,comp);
+int icalset_has_uid(icalset* set, const char* uid) {
+    return set->has_uid(set, uid);
 }
 
+icalerrorenum icalset_modify(icalset* set, icalcomponent *old,
+                               icalcomponent *new) {
+    return set->modify(set, old, new);
+}
 
-int icalset_has_uid(icalset* set, const char* uid)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->has_uid))(impl.derived_impl,uid);
+icalcomponent* icalset_get_current_component(icalset* set) {
+    return set->get_current_component(set);
 }
 
-icalerrorenum icalset_modify(icalset* set, icalcomponent *old,
-                               icalcomponent *new)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->modify))(impl.derived_impl,old,new);
+icalcomponent* icalset_get_first_component(icalset* set) {
+    return set->get_first_component(set);
 }
 
-icalcomponent* icalset_get_current_component(icalset* set)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->get_current_component))(impl.derived_impl);
+icalcomponent* icalset_get_next_component(icalset* set) {
+    return set->get_next_component(set);
 }
 
-icalcomponent* icalset_get_first_component(icalset* set)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->get_first_component))(impl.derived_impl);
+icalsetiter icalsetiter_null = {{ICAL_NO_COMPONENT, 0}, 0};
+
+icalsetiter icalset_begin_component(icalset* set,
+                                 icalcomponent_kind kind, icalgauge* gauge) {
+    return set->icalset_begin_component(set, kind, gauge);
 }
 
-icalcomponent* icalset_get_next_component(icalset* set)
-{
-    struct icalset_impl impl = icalset_get_impl(set);
-    return (*(impl.fp->get_next_component))(impl.derived_impl);
+icalcomponent* icalsetiter_next(icalsetiter* itr) {
+
+    icalcomponent* c = 0;
+    icalerror_check_arg_rz( (itr != NULL), "i");
+
+    do  {
+        c = icalcompiter_next(&(itr->iter));
+        if(c != 0 && (itr->gauge == 0 ||
+                        icalgauge_compare(itr->gauge, c) == 1)){
+            return c;
+        }
+    } while (c != 0);
+
+    return 0;
+}
+
+icalcomponent* icalsetiter_prior(icalsetiter* i) {
+
+    icalcomponent* c = 0;
+    icalerror_check_arg_rz( (i != NULL), "i" );
+
+    do  {
+        c = icalcompiter_prior(&(i->iter));
+        if(c != 0 && (i->gauge == 0 ||
+                        icalgauge_compare(i->gauge, c) == 1)){
+            return c;
 }
+    } while (c != 0);
 
+    return 0;
+}
 
+icalcomponent* icalsetiter_deref(icalsetiter* i) {
+    icalerror_check_arg_rz( (i != NULL), "i" );
+    return (icalcompiter_deref(&(i->iter)));
+}
 
+/* for subclasses that use multiple clusters that require specialized cluster traversal */
+icalcomponent* icalsetiter_to_next(icalset* set, icalsetiter* i)
+{
+    return set->icalsetiter_to_next(set, i);
+}
 
+icalcomponent* icalsetiter_to_prior(icalset* set, icalsetiter* i)
+{
+    return set->icalsetiter_to_prior(set, i);
+}