GNOME.org
 

[evolution-kolab/ek-wip-porting-imapx: 11/12] CamelKolabImapxMetadata: build fixes, refactoring

commit 096fb5317bf02cafe135b271a030c7bc6e445d9d
Author: Christian Hilberg <hilberg kernelconcepts de>
Date:   Wed Nov 30 12:13:03 2011 +0100

    CamelKolabImapxMetadata: build fixes, refactoring
    
    * renamed CamelKolabIMAPXMetaData to CamelKolabImapxMetadata
      (GObject-style casing, make it distinguishable from upstream
      IMAPX classes)
    * renamed all functions to the camel_kolab_imapx_metadata_*
      scheme
    * initialized all function vars
    * replaced CamelException with GError
    * reflect Camel API changes (CamelStore, CamelService)
    * include the single Camel lib header (via our
      Camel system header wrapper) instead of individual
      Camel headers (the latter is not allowed any longer,
      with the exception of our local IMAPX headers)
    * moved CamelKolabIMAPXFolderMetadata functions to
      CamelKolabIMAPXFolderMetadata
    * let destruction functions return void instead of
      gboolean if they do mem I/O only

 src/camel/camel-kolab-imapx-metadata.c |  455 ++++++++++++++++----------------
 src/camel/camel-kolab-imapx-metadata.h |   33 +--
 2 files changed, 242 insertions(+), 246 deletions(-)
---
diff --git a/src/camel/camel-kolab-imapx-metadata.c b/src/camel/camel-kolab-imapx-metadata.c
index 6b3e3d3..0c3e0c1 100644
--- a/src/camel/camel-kolab-imapx-metadata.c
+++ b/src/camel/camel-kolab-imapx-metadata.c
@@ -31,6 +31,7 @@
 
 #include <camel/providers/imapx/camel-imapx-store.h>
 #include <camel/providers/imapx/camel-imapx-server.h>
+#include <camel/providers/imapx/camel-imapx-server-extn.h>
 #include <camel/providers/imapx/camel-imapx-utils.h>
 
 /* Kolab error reporting */
@@ -69,7 +70,7 @@ static GHashTable *kolab_folder_type_map = NULL;
 /*----------------------------------------------------------------------------*/
 
 static void
-kolab_folder_destroy_type_map (void)
+camel_kolab_imapx_folder_destroy_type_map (void)
 {
 	if (kolab_folder_type_map != NULL) {
 		g_hash_table_destroy (kolab_folder_type_map);
@@ -78,10 +79,10 @@ kolab_folder_destroy_type_map (void)
 }
 
 static void
-kolab_folder_build_type_map (void)
+camel_kolab_imapx_folder_build_type_map (void)
 {
-	gint ii;
-	kolab_folder_destroy_type_map ();
+	gint ii = 0;
+	camel_kolab_imapx_folder_destroy_type_map ();
 	kolab_folder_type_map = g_hash_table_new (g_str_hash, g_str_equal);
 	for (ii = 0; ii < KOLAB_FOLDER_LAST_TYPE; ii++) {
 		kolab_folder_type_nums[ii] = ii;
@@ -92,20 +93,21 @@ kolab_folder_build_type_map (void)
 }
 
 static KolabFolderTypeID
-kolab_folder_map_get_type_id (const gchar *typestring, GError **err)
+camel_kolab_imapx_folder_map_get_type_id (const gchar *typestring,
+                                          GError **err)
 {
 	/* when looking up a value from kolab_folder_type_map, store
 	 * it in gpointer, check for NULL, then dereference and cast
 	 * to KolabFolderTypeID
 	 */
-	gpointer map_entry;
-	KolabFolderTypeID id;
+	gpointer map_entry = NULL;
+	KolabFolderTypeID id = KOLAB_FOLDER_TYPE_INVAL;
 
 	g_assert (kolab_folder_type_map != NULL);
 	g_assert (typestring != NULL);
+	g_return_val_if_fail (err == NULL || *err == NULL, KOLAB_FOLDER_TYPE_INVAL);
 
-	map_entry = g_hash_table_lookup (kolab_folder_type_map,
-	                                 typestring);
+	map_entry = g_hash_table_lookup (kolab_folder_type_map, typestring);
 
 	if (map_entry == NULL) {
 		/* this would be a Kolab format error from server */
@@ -121,66 +123,52 @@ kolab_folder_map_get_type_id (const gchar *typestring, GError **err)
 	return id;
 }
 
-/*----------------------------------------------------------------------------*/
-
-CamelKolabFolderMetaData*
-kolab_folder_meta_data_new (void)
-{
-	CamelKolabFolderMetaData *kfmd;
-	kfmd = g_new0 (CamelKolabFolderMetaData, 1);
-	kfmd->folder_type = KOLAB_FOLDER_TYPE_INVAL;
-	return kfmd;
-}
-
-gboolean
-kolab_folder_meta_data_free (CamelKolabFolderMetaData *kfmd)
+static gchar*
+camel_kolab_imapx_folder_map_get_type_string (KolabFolderTypeID foldertype)
 {
-	if (kfmd == NULL)
-		return TRUE;
-	g_free (kfmd);
-	return TRUE;
+	g_assert (foldertype < KOLAB_FOLDER_LAST_TYPE);
+	return kolab_folder_type_inv_map[foldertype];
 }
 
-static void
-kolab_folder_meta_data_gdestroy (gpointer data)
-{
-	CamelKolabFolderMetaData *kfmd = (CamelKolabFolderMetaData *)data;
-	(void)kolab_folder_meta_data_free (kfmd);
-}
+/*----------------------------------------------------------------------------*/
 
-static CamelKolabFolderMetaData*
-kolab_folder_meta_data_new_from_imapx_annotation (CamelIMAPXMetaAnnotation *man,
-                                                  CamelIMAPXServer *server,
-                                                  GError **err)
+static CamelKolabImapxFolderMetadata*
+camel_kolab_imapx_folder_metadata_new_from_imapx_annotation (CamelImapxMetadataAnnotation *man,
+                                                             CamelIMAPXServer *server,
+                                                             GError **err)
 {
-	CamelKolabFolderMetaData *kfmd;
-	CamelIMAPXMetaAttrib *ma;
-	CamelIMAPXMetaDataSpec *spec;
+	CamelKolabImapxFolderMetadata *kfmd = NULL;
+	CamelImapxMetadataAttrib *ma = NULL;
+	CamelImapxMetadataSpec *spec = NULL;
+	camel_imapx_metadata_proto_t proto = CAMEL_IMAPX_METADATA_PROTO_INVAL;	
+	gchar *typestring = NULL;
 	GError *tmp_err = NULL;
-	gchar *typestring;
 
-	g_assert (server != NULL);
+	/* man may be NULL */
+	g_assert (CAMEL_IS_IMAPX_SERVER (server));
 	g_return_val_if_fail (err == NULL || *err == NULL, NULL);
 
 	if (man == NULL)
 		return NULL;
+	
 	g_assert (man->entries != NULL);
 
 	/* search for folder type info */
-	spec = __KOLAB_imapx_meta_data_spec_new (server->metadata, /* to get protocol type */
-	                                         NULL, /* search starts at annotation */
-	                                         "/vendor/kolab/folder-type",
-	                                         NULL, /* "value" will be substituted */
-	                                         &tmp_err);
+	proto = camel_imapx_server_metadata_get_proto (server);
+	spec = camel_imapx_metadata_spec_new (proto, /* IMAP metadata protocol type */
+	                                      NULL, /* search starts at annotation */
+	                                      "/vendor/kolab/folder-type",
+	                                      NULL, /* "value" will be substituted */
+	                                      &tmp_err);
 	if (spec == NULL) {
 		g_propagate_error (err, tmp_err);
 		return NULL;
 	}
 
-	kfmd = kolab_folder_meta_data_new ();
+	kfmd = camel_kolab_imapx_folder_metadata_new ();
 
-	ma = __KOLAB_imapx_meta_data_get_attrib_from_annotation (man, spec);
-	__KOLAB_imapx_meta_data_spec_free (spec);
+	ma = camel_imapx_metadata_get_attrib_from_annotation (man, spec);
+	camel_imapx_metadata_spec_free (spec);
 
 	if (ma == NULL) {
 		/* no folder type info available */
@@ -191,11 +179,11 @@ kolab_folder_meta_data_new_from_imapx_annotation (CamelIMAPXMetaAnnotation *man,
 	g_assert (ma->data != NULL);
 	g_assert (ma->type != NULL);
 
-	if (ma->type[CAMEL_IMAPX_METADATA_ACCESS_SHARED] != CAMEL_IMAPX_META_ATTRIB_TYPE_UTF8) {
+	if (ma->type[CAMEL_IMAPX_METADATA_ACCESS_SHARED] != CAMEL_IMAPX_METADATA_ATTRIB_TYPE_UTF8) {
 		/* protocol violation - kolab folder type
 		 * string must be an UTF-8 shared value
 		 */
-		kolab_folder_meta_data_free (kfmd);
+		camel_kolab_imapx_folder_metadata_free (kfmd);
 		g_set_error (err,
 		             KOLAB_CAMEL_KOLAB_ERROR,
 		             KOLAB_CAMEL_KOLAB_ERROR_FORMAT,
@@ -205,10 +193,10 @@ kolab_folder_meta_data_new_from_imapx_annotation (CamelIMAPXMetaAnnotation *man,
 	}
 
 	typestring = (gchar*) ma->data[CAMEL_IMAPX_METADATA_ACCESS_SHARED]->data;
-	kfmd->folder_type = kolab_folder_map_get_type_id (typestring, &tmp_err);
+	kfmd->folder_type = camel_kolab_imapx_folder_map_get_type_id (typestring, &tmp_err);
 	if (kfmd->folder_type == KOLAB_FOLDER_TYPE_INVAL) {
 		/* protocol violation - invalid kolab folder type string */
-		kolab_folder_meta_data_free (kfmd);
+		camel_kolab_imapx_folder_metadata_free (kfmd);
 		g_propagate_error (err, tmp_err);
 		return NULL;
 	}
@@ -218,130 +206,127 @@ kolab_folder_meta_data_new_from_imapx_annotation (CamelIMAPXMetaAnnotation *man,
 
 /*----------------------------------------------------------------------------*/
 
-CamelKolabIMAPXMetaData*
-kolab_imapx_meta_data_new (void)
+CamelKolabImapxMetadata*
+camel_kolab_imapx_metadata_new (void)
 {
-	CamelKolabIMAPXMetaData *kmd;
-	kmd = g_new0 (CamelKolabIMAPXMetaData, 1);
+	CamelKolabImapxMetadata *kmd = g_new0 (CamelKolabImapxMetadata, 1);
 	kmd->mdb = NULL;
 	kmd->kolab_metadata = g_hash_table_new_full (g_str_hash,
 	                                             g_str_equal,
 	                                             g_free,
-	                                             kolab_folder_meta_data_gdestroy);
+	                                             camel_kolab_imapx_folder_metadata_gdestroy);
 
 	return kmd;
 }
 
-gboolean
-kolab_imapx_meta_data_free (CamelKolabIMAPXMetaData *kmd)
+void
+camel_kolab_imapx_metadata_free (CamelKolabImapxMetadata *kmd)
 {
 	if (kmd == NULL)
-		return TRUE;
+		return;
 
 	if (kmd->kolab_metadata)
 		/* need hash table with key:val destroy function set */
 		g_hash_table_destroy (kmd->kolab_metadata);
 
 	g_free (kmd);
-	return TRUE;
 }
 
 gboolean
-kolab_imapx_meta_data_init (CamelKolabIMAPXMetaData *kmd,
-                            CamelService* service,
-                            CamelSession* session,
-                            GError** err)
+camel_kolab_imapx_metadata_init (CamelKolabImapxMetadata *kmd,
+				 CamelService *service,
+				 CamelSession *session,
+				 GError **err)
 {
+	gboolean db_ok = FALSE;
 	GError *tmp_err = NULL;
-	gboolean db_ok;
 
 	g_assert (kmd != NULL);
-	g_assert (service != NULL);
-	g_assert (session != NULL);
+	g_assert (CAMEL_IS_SERVICE (service));
+	g_assert (CAMEL_IS_SESSION (session));
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
 	if (kmd->mdb == NULL)
-		kmd->mdb = kolab_imapx_meta_data_db_new ();
+		kmd->mdb = camel_kolab_imapx_metadata_db_new ();
 
-	db_ok = kolab_imapx_meta_data_db_open (kmd->mdb, service, session, &tmp_err);
+	db_ok = camel_kolab_imapx_metadata_db_open (kmd->mdb, service, session, &tmp_err);
 	if (!db_ok) {
 		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
 
-	db_ok = kolab_imapx_meta_data_db_init (kmd->mdb, &tmp_err);
+	db_ok = camel_kolab_imapx_metadata_db_init (kmd->mdb, &tmp_err);
 	if (!db_ok) {
 		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
 
-	kolab_folder_build_type_map ();
+	camel_kolab_imapx_folder_build_type_map ();
 
-	/* TODO call to __KOLAB_imapx_meta_data_init? */
+	/* TODO call to camel_kolab_imapx_metadata_init? */
 
 	return TRUE;
 }
 
 gboolean
-kolab_imapx_meta_data_uninit (CamelKolabIMAPXMetaData *kmd,
-                              GError** err)
+camel_kolab_imapx_metadata_uninit (CamelKolabImapxMetadata *kmd,
+                                   GError **err)
 {
 	GError *tmp_err = NULL;
-	gboolean db_ok;
+	gboolean db_ok = FALSE;
 
 	g_assert (kmd != NULL);
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
-	db_ok = kolab_imapx_meta_data_db_close (kmd->mdb, &tmp_err);
+	db_ok = camel_kolab_imapx_metadata_db_close (kmd->mdb, &tmp_err);
 	if (!db_ok) {
 		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
 
-	kolab_folder_destroy_type_map ();
+	camel_kolab_imapx_folder_destroy_type_map ();
 
-	/* TODO call to __KOLAB_imapx_meta_data_uninit? */
+	/* TODO call to camel_kolab_imapx_metadata_uninit? */
 
 	return TRUE;
 }
 
 static void
-kolab_meta_data_addreplace_from_imapx (CamelKolabIMAPXMetaData *kmd,
-                                       CamelIMAPXMetaData *md,
-                                       CamelIMAPXServer *server)
+camel_kolab_imapx_metadata_addreplace_from_imapx (CamelKolabImapxMetadata *kmd,
+                                                  CamelImapxMetadata *md,
+                                                  CamelIMAPXServer *server)
 {
 	/* TODO error reporting */
 
 	GHashTableIter mbox_iter;
-	gpointer mbox_key;
-	gpointer mbox_value;
+	gpointer mbox_key = NULL;
+	gpointer mbox_value = NULL;
+	gchar *foldername = NULL;
+	CamelImapxMetadataAnnotation *man = NULL;
+	CamelKolabImapxFolderMetadata *kfmd = NULL;
 	GError *tmp_err = NULL;
 
-	gchar *folder_name;
-	CamelIMAPXMetaAnnotation *man;
-	CamelKolabFolderMetaData *kfmd;
-
 	g_assert (kmd != NULL);
 	g_assert (md != NULL);
-	g_assert (server != NULL);
+	g_assert (CAMEL_IS_IMAPX_SERVER (server));
 
 	g_hash_table_iter_init (&mbox_iter, md->mboxes);
 	while (g_hash_table_iter_next (&mbox_iter, &mbox_key, &mbox_value)) {
-		folder_name = (gchar*) mbox_key;
-		man = (CamelIMAPXMetaAnnotation*) mbox_value;
+		foldername = (gchar*) mbox_key;
+		man = (CamelImapxMetadataAnnotation*) mbox_value;
 
-		kfmd = kolab_folder_meta_data_new_from_imapx_annotation (man,
-		                                                         server,
-		                                                         &tmp_err);
+		kfmd = camel_kolab_imapx_folder_metadata_new_from_imapx_annotation (man,
+		                                                                    server,
+		                                                                    &tmp_err);
 		if (kfmd == NULL) {
 			g_warning ("%s: kolab annotation error for [%s]: %s",
-			           __func__, folder_name, tmp_err->message);
+			           __func__, foldername, tmp_err->message);
 			g_clear_error (&tmp_err);
 			continue;
 		}
 		/* need hash table with key:value destroy functions set */
 		g_hash_table_replace (kmd->kolab_metadata,
-		                      g_strdup (folder_name),
+		                      g_strdup (foldername),
 		                      kfmd);
 	}
 }
@@ -350,143 +335,153 @@ kolab_meta_data_addreplace_from_imapx (CamelKolabIMAPXMetaData *kmd,
  *                  become too long!
  */
 gboolean
-kolab_imapx_meta_data_query_all_folder_types (CamelService *service,
-                                              GError **err)
+camel_kolab_imapx_metadata_query_all_folder_types (CamelService *service,
+                                                   GCancellable *cancellable,
+                                                   GError **err)
 {
-	CamelIMAPXServer *server;
-	CamelIMAPXMetaDataSpec *spec;
-
+	CamelIMAPXServer *server = NULL;
+	CamelImapxMetadataSpec *spec = NULL;
+	camel_imapx_metadata_proto_t proto = CAMEL_IMAPX_METADATA_PROTO_INVAL;
 	GError *tmp_err = NULL;
-	CamelException *tmp_ex;
 
-	g_assert (service != NULL);
+	g_assert (CAMEL_IS_SERVICE (service));
+	g_assert (G_IS_CANCELLABLE (cancellable));
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
-	tmp_ex = camel_exception_new ();
-	server = __KOLAB_camel_imapx_store_get_server ((CamelIMAPXStore *)service, tmp_ex);
+	server = camel_imapx_store_get_server (CAMEL_IMAPX_STORE (service),
+	                                       (const gchar*)NULL, /* FIXME does that work?? */
+	                                       cancellable,
+	                                       &tmp_err);
 	if (server == NULL) {
-		kolab_gerror_propagate_from_camelexception (err, tmp_ex, KOLAB_CAMEL_KOLAB_ERROR);
+		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
 
-	spec = __KOLAB_imapx_meta_data_spec_new (server->metadata,
-	                                         "*",
-	                                         "/vendor/kolab/folder-type",
-	                                         "value",
-	                                         &tmp_err);
+	proto = camel_imapx_server_metadata_get_proto (server);
+	spec = camel_imapx_metadata_spec_new (proto,
+	                                      "*",
+	                                      "/vendor/kolab/folder-type",
+	                                      "value",
+	                                      &tmp_err);
 	if (spec == NULL) {
-		camel_exception_free (tmp_ex);
 		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
 
-	(void)__KOLAB_imapx_server_get_metadata (server, spec, FALSE, tmp_ex);
-	if (camel_exception_is_set (tmp_ex)) {
-		__KOLAB_imapx_meta_data_spec_free (spec);
-		kolab_gerror_propagate_from_camelexception (err, tmp_ex, KOLAB_CAMEL_KOLAB_ERROR);
+	/* fetch annotations from server, do not resect the data
+	 * from CamelIMAPXServer as yet
+	 */
+	(void)camel_imapx_server_get_metadata (server, spec, FALSE, &tmp_err);
+	if (tmp_err != NULL) {
+		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
-	__KOLAB_imapx_meta_data_spec_free (spec);
-	camel_exception_free (tmp_ex);
+	camel_imapx_metadata_spec_free (spec);
 
 	return TRUE;
 }
 
 KolabFolderTypeID
-kolab_imapx_meta_data_get_foldertype (CamelKolabIMAPXMetaData *kmd,
-                                      CamelService *service,
-                                      const gchar *folder_name,
-                                      gboolean do_updatedb,
-                                      GError **err)
+camel_kolab_imapx_metadata_get_foldertype (CamelKolabImapxMetadata *kmd,
+                                           CamelService *service,
+                                           const gchar *foldername,
+                                           gboolean do_updatedb,
+                                           GCancellable *cancellable,
+                                           GError **err)
 {
 	/* TODO better error reporting */
 
-	CamelIMAPXServer *server;
-	CamelStore *store;
-	CamelIMAPXMetaData *md;
-	CamelKolabFolderMetaData *kfmd;
-	CamelIMAPXMetaDataSpec *spec;
+	CamelIMAPXServer *server = NULL;
+	CamelStore *store = NULL;
+	CamelImapxMetadata *md = NULL;
+	CamelKolabImapxFolderMetadata *kfmd = NULL;
+	CamelImapxMetadataSpec *spec = NULL;
+	camel_imapx_metadata_proto_t proto = CAMEL_IMAPX_METADATA_PROTO_INVAL;
+	gboolean db_ok = FALSE;
 	GError *tmp_err = NULL;
-	CamelException *tmp_ex;
-	gboolean db_ok;
 
 	g_assert (kmd != NULL);
 	g_assert (kmd->kolab_metadata != NULL);
 	g_assert (kmd->mdb != NULL);
-	g_assert (service != NULL);
-	g_assert (folder_name != NULL);
+	g_assert (CAMEL_IS_SERVICE (service));
+	g_assert (foldername != NULL);
+	g_assert (G_IS_CANCELLABLE (cancellable));
 	g_return_val_if_fail (err == NULL || *err == NULL, KOLAB_FOLDER_TYPE_INVAL);
 
 	/* hash table lookup */
-	kfmd = g_hash_table_lookup (kmd->kolab_metadata, folder_name);
+	kfmd = g_hash_table_lookup (kmd->kolab_metadata, foldername);
 	if (kfmd != NULL)
 		return kfmd->folder_type;
 
 	/* if not in hash table: sqlite db lookup */
-	kfmd = kolab_imapx_meta_data_db_lookup (kmd->mdb,
-	                                        folder_name,
-	                                        &tmp_err);
+	kfmd = camel_kolab_imapx_metadata_db_lookup (kmd->mdb,
+	                                             foldername,
+	                                             &tmp_err);
 	if (tmp_err != NULL) {
 		g_propagate_error (err, tmp_err);
 		return KOLAB_FOLDER_TYPE_INVAL;
 	}
 	if (kfmd != NULL) {
 		g_hash_table_insert (kmd->kolab_metadata,
-		                     g_strdup (folder_name),
+		                     g_strdup (foldername),
 		                     kfmd);
 		return kfmd->folder_type;
 	}
 
 	/* check whether we're online */
-	store = (CamelStore *) service;
-	if (CAMEL_OFFLINE_STORE (store)->state == CAMEL_OFFLINE_STORE_NETWORK_UNAVAIL)
+	store = CAMEL_STORE (service);
+	if (! camel_offline_store_get_online (CAMEL_OFFLINE_STORE (store)))
 		return KOLAB_FOLDER_TYPE_UNKNOWN;
 
 	/* TODO check whether we're authenticated */
 
 	/* if not in sqlite db: issue IMAP query */
-	tmp_ex = camel_exception_new ();
-	server = __KOLAB_camel_imapx_store_get_server ((CamelIMAPXStore *)service, tmp_ex);
-	if (server == NULL) {
-		kolab_gerror_propagate_from_camelexception (err, tmp_ex, KOLAB_CAMEL_KOLAB_ERROR);
+	server = camel_imapx_store_get_server (CAMEL_IMAPX_STORE (service),
+	                                       foldername,
+	                                       cancellable,
+	                                       &tmp_err);
+	if (tmp_err != NULL) {
+		g_propagate_error (err, tmp_err);
 		return KOLAB_FOLDER_TYPE_INVAL;
 	}
-	spec = __KOLAB_imapx_meta_data_spec_new (server->metadata,
-	                                         folder_name,
-	                                         "/vendor/kolab/folder-type",
-	                                         "value",
-	                                         &tmp_err);
+
+	proto = camel_imapx_server_metadata_get_proto (server);
+	spec = camel_imapx_metadata_spec_new (proto,
+	                                      foldername,
+	                                      "/vendor/kolab/folder-type",
+	                                      "value",
+	                                      &tmp_err);
 	if (spec == NULL) {
-		camel_object_unref (server);
+		g_object_unref (server);
 		g_propagate_error (err, tmp_err);
 		return KOLAB_FOLDER_TYPE_INVAL;
 	}
 
-	md = __KOLAB_imapx_server_get_metadata (server, spec, TRUE, tmp_ex);
+	/* resect all metadata gathered so far from CamelIMAPXServer */
+	md = camel_imapx_server_get_metadata (server, spec, TRUE, &tmp_err);
 
 	if (md == NULL) {
-		if (camel_exception_is_set (tmp_ex)) {
-			camel_object_unref (server);
-			__KOLAB_imapx_meta_data_spec_free (spec);
-			kolab_gerror_propagate_from_camelexception (err, tmp_ex, KOLAB_CAMEL_KOLAB_ERROR);
+		if (tmp_err != NULL) {
+			g_object_unref (server);
+			camel_imapx_metadata_spec_free (spec);
+			g_propagate_error (err, tmp_err);
 			return KOLAB_FOLDER_TYPE_INVAL;
 		}
 	}
-	__KOLAB_imapx_meta_data_spec_free (spec);
-	camel_exception_free (tmp_ex);
+	camel_imapx_metadata_spec_free (spec);
 
 	/* create kolab "flat" data structure */
-	kolab_meta_data_addreplace_from_imapx (kmd, md, server);
-	__KOLAB_imapx_meta_data_free (md);
+	camel_kolab_imapx_metadata_addreplace_from_imapx (kmd, md, server);
+	camel_imapx_metadata_free (md);
 
 	/* unref server */
-	camel_object_unref (server);
+	g_object_unref (server);
 
 	/* stuff folder types into metadata_db */
 	if (do_updatedb) {
-		db_ok = kolab_imapx_meta_data_db_update (kmd->mdb,
-			                                 kmd->kolab_metadata,
-			                                 &tmp_err);
+		db_ok = camel_kolab_imapx_metadata_db_update (kmd->mdb,
+		                                              kmd->kolab_metadata,
+		                                              &tmp_err);
 		if (!db_ok) {
 			g_propagate_error (err, tmp_err);
 			return KOLAB_FOLDER_TYPE_INVAL;
@@ -494,44 +489,46 @@ kolab_imapx_meta_data_get_foldertype (CamelKolabIMAPXMetaData *kmd,
 	}
 
 	/* final hash table lookup */
-	kfmd = g_hash_table_lookup (kmd->kolab_metadata, folder_name);
-	if (kfmd != NULL)
-		return kfmd->folder_type;
+	kfmd = g_hash_table_lookup (kmd->kolab_metadata, foldername);
+	if (kfmd == NULL)
+		return KOLAB_FOLDER_TYPE_UNKNOWN;
 
-	return KOLAB_FOLDER_TYPE_UNKNOWN;
+	return kfmd->folder_type;
 }
 
 gboolean
-kolab_imapx_meta_data_set_foldertype (CamelKolabIMAPXMetaData *kmd,
-                                      CamelService *service,
-                                      const gchar *folder_name,
-                                      KolabFolderTypeID folder_type,
-                                      GError **err)
+camel_kolab_imapx_metadata_set_foldertype (CamelKolabImapxMetadata *kmd,
+                                           CamelService *service,
+                                           const gchar *foldername,
+                                           KolabFolderTypeID foldertype,
+                                           GCancellable *cancellable,
+                                           GError **err)
 {
-	CamelIMAPXServer *server;
-	CamelStore *store;
-	CamelIMAPXMetaData *md;
-	CamelIMAPXMetaAnnotation *man;
-	CamelIMAPXMetaEntry *me;
-	CamelIMAPXMetaAttrib *ma;
-	gchar *type_str;
-	imapx_meta_data_access_t acc;
-	CamelException *tmp_ex;
+	CamelIMAPXServer *server = NULL;
+	CamelStore *store = NULL;
+	CamelImapxMetadata *md = NULL;
+	CamelImapxMetadataAnnotation *man = NULL;
+	CamelImapxMetadataEntry *me = NULL;
+	CamelImapxMetadataAttrib *ma = NULL;
+	gchar *type_str = NULL;
+	camel_imapx_metadata_access_t acc = CAMEL_IMAPX_METADATA_ACCESS_SHARED;
+	camel_imapx_metadata_proto_t proto = CAMEL_IMAPX_METADATA_PROTO_INVAL;
+	gboolean metadata_ok = FALSE;
+	gboolean db_ok = FALSE;
 	GError *tmp_err = NULL;
-	gboolean metadata_ok;
-	gboolean db_ok;
 
 	g_assert (kmd != NULL);
 	g_assert (kmd->kolab_metadata != NULL);
 	g_assert (kmd->mdb != NULL);
-	g_assert (service != NULL);
-	g_assert (folder_name != NULL);
-	g_assert ((folder_type > KOLAB_FOLDER_TYPE_UNKNOWN) && (folder_type < KOLAB_FOLDER_LAST_TYPE));
+	g_assert (CAMEL_IS_SERVICE (service));
+	g_assert (foldername != NULL);
+	g_assert ((foldertype > KOLAB_FOLDER_TYPE_UNKNOWN) && (foldertype < KOLAB_FOLDER_LAST_TYPE));
+	g_assert (G_IS_CANCELLABLE (cancellable));
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
 	/* check whether we're online */
-	store = (CamelStore *) service;
-	if (CAMEL_OFFLINE_STORE (store)->state == CAMEL_OFFLINE_STORE_NETWORK_UNAVAIL) {
+	store = CAMEL_STORE (service);
+	if (! camel_offline_store_get_online (CAMEL_OFFLINE_STORE (store))) {
 		g_set_error (err,
 		             KOLAB_CAMEL_KOLAB_ERROR,
 		             KOLAB_CAMEL_KOLAB_ERROR_SERVER,
@@ -543,57 +540,61 @@ kolab_imapx_meta_data_set_foldertype (CamelKolabIMAPXMetaData *kmd,
 	/* TODO check whether we're authenticated */
 
 	/* get the server object */
-	tmp_ex = camel_exception_new ();
-	server = __KOLAB_camel_imapx_store_get_server ((CamelIMAPXStore *)service, tmp_ex);
-	if (server == NULL) {
-		kolab_gerror_propagate_from_camelexception (err, tmp_ex, KOLAB_CAMEL_KOLAB_ERROR);
+	server = camel_imapx_store_get_server (CAMEL_IMAPX_STORE (service),
+	                                       foldername,
+	                                       cancellable,
+	                                       &tmp_err);
+	if (tmp_err != NULL) {
+		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
 
-	/* create local CamelIMAPXMetaData for setting type */
+	/* create local CamelImapxMetadata for setting type */
 	acc = CAMEL_IMAPX_METADATA_ACCESS_SHARED;
-	ma = __KOLAB_imapx_meta_attrib_new ();
-	ma->type[acc] = CAMEL_IMAPX_META_ATTRIB_TYPE_UTF8;
-	type_str = kolab_folder_type_inv_map[folder_type];
+	ma = camel_imapx_metadata_attrib_new ();
+	ma->type[acc] = CAMEL_IMAPX_METADATA_ATTRIB_TYPE_UTF8;
+	type_str = camel_kolab_imapx_folder_map_get_type_string (foldertype);
 	ma->data[acc] = g_byte_array_new ();
 	g_byte_array_append (ma->data[acc],
 	                     (guchar *) type_str,
 	                     strlen (type_str));
-	me = __KOLAB_imapx_meta_entry_new ();
+	me = camel_imapx_metadata_entry_new ();
 	g_hash_table_insert (me->attributes,
 	                     g_strdup ("value"),
 	                     ma);
-	man = __KOLAB_imapx_meta_annotation_new ();
+	man = camel_imapx_metadata_annotation_new ();
 	g_hash_table_insert (man->entries,
 	                     g_strdup ("/vendor/kolab/folder-type"),
 	                     me);
-	md = __KOLAB_imapx_meta_data_new (__KOLAB_imapx_meta_data_get_proto (server->metadata),
-	                                  FALSE);
+	proto = camel_imapx_server_metadata_get_proto (server);
+	md = camel_imapx_metadata_new (proto, FALSE);
 	g_hash_table_insert (md->mboxes,
-	                     g_strdup (folder_name),
+	                     g_strdup (foldername),
 	                     man);
 
 	/* set folder type on the server */
-	metadata_ok = __KOLAB_imapx_server_set_metadata (server, md, tmp_ex);
-	if (!metadata_ok) {
-		__KOLAB_imapx_meta_data_free (md);
-		camel_object_unref (server);
-		kolab_gerror_propagate_from_camelexception (err, tmp_ex, KOLAB_CAMEL_KOLAB_ERROR);
+	metadata_ok = camel_imapx_server_set_metadata (server,
+	                                               md,
+	                                               &tmp_err);
+	if (! metadata_ok) {
+		camel_imapx_metadata_free (md);
+		g_object_unref (server);
+		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
 
 	/* create kolab "flat" data structure */
-	kolab_meta_data_addreplace_from_imapx (kmd, md, server);
-	__KOLAB_imapx_meta_data_free (md);
+	camel_kolab_imapx_metadata_addreplace_from_imapx (kmd, md, server);
+	camel_imapx_metadata_free (md);
 
 	/* unref server */
-	camel_object_unref (server);
+	g_object_unref (server);
 
 	/* stuff folder types into metadata_db */
-	db_ok = kolab_imapx_meta_data_db_update (kmd->mdb,
-		                                 kmd->kolab_metadata,
-		                                 &tmp_err);
-	if (!db_ok) {
+	db_ok = camel_kolab_imapx_metadata_db_update (kmd->mdb,
+	                                              kmd->kolab_metadata,
+	                                              &tmp_err);
+	if (! db_ok) {
 		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
@@ -602,13 +603,13 @@ kolab_imapx_meta_data_set_foldertype (CamelKolabIMAPXMetaData *kmd,
 }
 
 gboolean
-kolab_imapx_meta_data_remove (CamelKolabIMAPXMetaData *kmd,
-                              const gchar *folder_name,
-                              GError **err)
+camel_kolab_imapx_metadata_remove (CamelKolabImapxMetadata *kmd,
+                                   const gchar *foldername,
+                                   GError **err)
 {
+	gboolean db_ok = FALSE;
+	gboolean mem_ok = FALSE;
 	GError *tmp_err = NULL;
-	gboolean db_ok;
-	gboolean mem_ok;
 
 	/* remove from local cache only, let the imap daemon
 	 * take care of the server side.
@@ -620,14 +621,14 @@ kolab_imapx_meta_data_remove (CamelKolabIMAPXMetaData *kmd,
 	g_assert (kmd != NULL);
 	g_assert (kmd->mdb != NULL);
 	g_assert (kmd->kolab_metadata != NULL);
-	g_assert (folder_name != NULL);
+	g_assert (foldername != NULL);
 	g_return_val_if_fail (err == NULL || *err == NULL, FALSE);
 
 	/* remove from metadata db */
-	db_ok = kolab_imapx_meta_data_db_remove_folder (kmd->mdb,
-	                                                folder_name,
-	                                                &tmp_err);
-	if (!db_ok) {
+	db_ok = camel_kolab_imapx_metadata_db_remove_folder (kmd->mdb,
+	                                                     foldername,
+	                                                     &tmp_err);
+	if (! db_ok) {
 		g_propagate_error (err, tmp_err);
 		return FALSE;
 	}
@@ -635,10 +636,12 @@ kolab_imapx_meta_data_remove (CamelKolabIMAPXMetaData *kmd,
 	/* remove from in-mem */
 	/* need hash table with key:value destroy functions set */
 	mem_ok = g_hash_table_remove (kmd->kolab_metadata,
-	                              folder_name);
-	if (!mem_ok)
+	                              foldername);
+	if (! mem_ok)
 		g_warning ("%s: [%s] not in mem cache",
-		           __func__, folder_name);
+		           __func__, foldername);
 
 	return TRUE;
 }
+
+/*----------------------------------------------------------------------------*/
diff --git a/src/camel/camel-kolab-imapx-metadata.h b/src/camel/camel-kolab-imapx-metadata.h
index b87ed9c..5529097 100644
--- a/src/camel/camel-kolab-imapx-metadata.h
+++ b/src/camel/camel-kolab-imapx-metadata.h
@@ -37,33 +37,26 @@
 #include <libekolabutil/kolab-util-folder.h>
 
 #include "camel-kolab-imapx-metadata-db.h"
+#include "camel-kolab-imapx-folder.h"
 
 /*----------------------------------------------------------------------------*/
 
-typedef struct _CamelKolabFolderMetaData {
-	/* folder name kept as key in CamelKolabIMAPXMetaData kolab_metadata  */
-	KolabFolderTypeID folder_type;
-} CamelKolabFolderMetaData;
-
-typedef struct _CamelKolabIMAPXMetaData {
-	CamelKolabIMAPXMetaDataDB  *mdb;	/* persistent DB */
-	GHashTable *kolab_metadata;		/* for CamelKolabFolderMetaData */
-} CamelKolabIMAPXMetaData;
+typedef struct _CamelKolabImapxMetadata {
+	CamelKolabImapxMetadataDb  *mdb;	/* persistent DB */
+	GHashTable *kolab_metadata;		/* for CamelKolabFolderMetadata */
+} CamelKolabImapxMetadata;
 
 /*----------------------------------------------------------------------------*/
 
-CamelKolabFolderMetaData *kolab_folder_meta_data_new (void);
-gboolean kolab_folder_meta_data_free (CamelKolabFolderMetaData*);
-
-CamelKolabIMAPXMetaData *kolab_imapx_meta_data_new (void);
-gboolean kolab_imapx_meta_data_free (CamelKolabIMAPXMetaData*);
-gboolean kolab_imapx_meta_data_init (CamelKolabIMAPXMetaData*, CamelService*, CamelSession*, GError**);
-gboolean kolab_imapx_meta_data_uninit (CamelKolabIMAPXMetaData*, GError**);
+CamelKolabImapxMetadata *camel_kolab_imapx_metadata_new (void);
+void camel_kolab_imapx_metadata_free (CamelKolabImapxMetadata *kmd);
+gboolean camel_kolab_imapx_metadata_init (CamelKolabImapxMetadata *kmd, CamelService *service, CamelSession *session, GError **err);
+gboolean camel_kolab_imapx_metadata_uninit (CamelKolabImapxMetadata *kmd, GError **err);
 
-gboolean kolab_imapx_meta_data_query_all_folder_types (CamelService*, GError**);
-KolabFolderTypeID kolab_imapx_meta_data_get_foldertype (CamelKolabIMAPXMetaData*, CamelService*, const gchar*, gboolean, GError**);
-gboolean kolab_imapx_meta_data_set_foldertype (CamelKolabIMAPXMetaData*, CamelService*, const gchar*, KolabFolderTypeID, GError**);
-gboolean kolab_imapx_meta_data_remove (CamelKolabIMAPXMetaData*, const gchar*, GError**);
+gboolean camel_kolab_imapx_metadata_query_all_folder_types (CamelService *service, GCancellable *cancellable, GError **err);
+KolabFolderTypeID camel_kolab_imapx_metadata_get_foldertype (CamelKolabImapxMetadata *kmd, CamelService *service, const gchar *foldername, gboolean do_updatedb, GCancellable *cancellable, GError **err);
+gboolean camel_kolab_imapx_metadata_set_foldertype (CamelKolabImapxMetadata *kmd, CamelService *serivce, const gchar *foldername, KolabFolderTypeID foldertype, GCancellable *cancellable, GError **err);
+gboolean camel_kolab_imapx_metadata_remove (CamelKolabImapxMetadata *kmd, const gchar *foldername, GError **err);
 
 /*----------------------------------------------------------------------------*/
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]