set backend's lock to TRUE.

2005-02-22  Rodrigo Moya <rodrigo@novell.com>

	* backends/http/e-cal-backend-http.c (e_cal_backend_http_init):
	* backends/groupwise/e-cal-backend-groupwise.c
	(e_cal_backend_groupwise_init):
	* backends/weather/e-cal-backend-weather.c
	(e_cal_backend_weather_init): set backend's lock to TRUE.

2005-02-22  JP Rosevear  <jpr@novell.com>

	* libedata-cal/e-cal-backend-sync.c: added a lock wrapper to make
	calls be locked if backend is set so.
	(e_cal_backend_sync_set_lock): new function.
	(e_cal_backend_sync_is_read_only, e_cal_backend_sync_get_cal_address,
	e_cal_backend_sync_get_alarm_email_address,
	e_cal_backend_sync_get_ldap_attribute,
	e_cal_backend_sync_get_static_capabilities, e_cal_backend_sync_open,
	e_cal_backend_sync_remove, e_cal_backend_sync_create_object,
	e_cal_backend_sync_modify_object, e_cal_backend_sync_remove_object,
	e_cal_backend_sync_discard_alarm, e_cal_backend_sync_receive_objects,
	e_cal_backend_sync_send_objects, e_cal_backend_sync_get_default_object,
	e_cal_backend_sync_get_object, e_cal_backend_sync_get_object_list,
	e_cal_backend_sync_get_timezone, e_cal_backend_sync_add_timezone,
	e_cal_backend_sync_set_default_timezone, e_cal_backend_sync_get_changes,
	e_cal_backend_sync_get_free_busy): wrap calls to backend methods in
	our lock wrapper.

	* backends/contacts/e-cal-backend-contacts.c
	(e_cal_backend_contacts_init):
	* backends/file/e-cal-backend-file.c (e_cal_backend_file_init):
	set backend's lock to TRUE.

diff --git a/calendar/ChangeLog b/calendar/ChangeLog
index 4360199..6b97259 100644 (file)
--- a/calendar/ChangeLog
+++ b/calendar/ChangeLog
@@ -1,3 +1,35 @@
+2005-02-22  Rodrigo Moya <rodrigo@novell.com>
+
+       * backends/http/e-cal-backend-http.c (e_cal_backend_http_init):
+       * backends/groupwise/e-cal-backend-groupwise.c
+       (e_cal_backend_groupwise_init):
+       * backends/weather/e-cal-backend-weather.c
+       (e_cal_backend_weather_init): set backend's lock to TRUE.
+
+2005-02-22  JP Rosevear  <jpr@novell.com>
+
+       * libedata-cal/e-cal-backend-sync.c: added a lock wrapper to make
+       calls be locked if backend is set so.
+       (e_cal_backend_sync_set_lock): new function.
+       (e_cal_backend_sync_is_read_only, e_cal_backend_sync_get_cal_address,
+       e_cal_backend_sync_get_alarm_email_address,
+       e_cal_backend_sync_get_ldap_attribute,
+       e_cal_backend_sync_get_static_capabilities, e_cal_backend_sync_open,
+       e_cal_backend_sync_remove, e_cal_backend_sync_create_object,
+       e_cal_backend_sync_modify_object, e_cal_backend_sync_remove_object,
+       e_cal_backend_sync_discard_alarm, e_cal_backend_sync_receive_objects,
+       e_cal_backend_sync_send_objects, e_cal_backend_sync_get_default_object,
+       e_cal_backend_sync_get_object, e_cal_backend_sync_get_object_list,
+       e_cal_backend_sync_get_timezone, e_cal_backend_sync_add_timezone,
+       e_cal_backend_sync_set_default_timezone, e_cal_backend_sync_get_changes,
+       e_cal_backend_sync_get_free_busy): wrap calls to backend methods in
+       our lock wrapper.
+
+       * backends/contacts/e-cal-backend-contacts.c
+       (e_cal_backend_contacts_init):
+       * backends/file/e-cal-backend-file.c (e_cal_backend_file_init):
+       set backend's lock to TRUE.
+
 2005-02-22  Chenthill Palanisamy  <pchenthill@novell.com>
 
        * backends/groupwise/e-cal-backend-groupwise-utils.c:

diff --git a/calendar/backends/contacts/e-cal-backend-contacts.c b/calendar/backends/contacts/e-cal-backend-contacts.c
index 3ae7f79..e03939b 100644 (file)
--- a/calendar/backends/contacts/e-cal-backend-contacts.c
+++ b/calendar/backends/contacts/e-cal-backend-contacts.c
@@ -933,6 +933,8 @@ e_cal_backend_contacts_init (ECalBackendContacts *cbc, ECalBackendContactsClass
        priv->default_zone = icaltimezone_get_utc_timezone ();
         
        cbc->priv = priv;
+
+       e_cal_backend_sync_set_lock (E_CAL_BACKEND_SYNC (cbc), TRUE);
 }
 
 /* Class initialization function for the contacts backend */

diff --git a/calendar/backends/file/e-cal-backend-file.c b/calendar/backends/file/e-cal-backend-file.c
index 32e926e..cf348cd 100644 (file)
--- a/calendar/backends/file/e-cal-backend-file.c
+++ b/calendar/backends/file/e-cal-backend-file.c
@@ -2430,7 +2430,7 @@ e_cal_backend_file_send_objects (ECalBackendSync *backend, EDataCal *cal, const
 
 /* Object initialization function for the file backend */
 static void
-e_cal_backend_file_init (ECalBackendFile *cbfile, ECalBackendFileClass *class)
+e_cal_backend_file_init (ECalBackendFile *cbfile)
 {
        ECalBackendFilePrivate *priv;
 
@@ -2449,6 +2449,8 @@ e_cal_backend_file_init (ECalBackendFile *cbfile, ECalBackendFileClass *class)
 
        /* The timezone defaults to UTC. */
        priv->default_zone = icaltimezone_get_utc_timezone ();
+
+       e_cal_backend_sync_set_lock (E_CAL_BACKEND_SYNC (cbfile), TRUE);
 }
 
 /* Class initialization function for the file backend */

diff --git a/calendar/backends/groupwise/e-cal-backend-groupwise.c b/calendar/backends/groupwise/e-cal-backend-groupwise.c
index feee2e8..4234204 100644 (file)
--- a/calendar/backends/groupwise/e-cal-backend-groupwise.c
+++ b/calendar/backends/groupwise/e-cal-backend-groupwise.c
@@ -1966,6 +1966,8 @@ e_cal_backend_groupwise_init (ECalBackendGroupwise *cbgw, ECalBackendGroupwiseCl
        priv->mutex = g_mutex_new ();
 
        cbgw->priv = priv;
+
+       e_cal_backend_sync_set_lock (E_CAL_BACKEND_SYNC (cbgw), TRUE);
 }
 
 /* Class initialization function for the gw backend */

diff --git a/calendar/backends/http/e-cal-backend-http.c b/calendar/backends/http/e-cal-backend-http.c
index 97ab9ac..b81d1dc 100644 (file)
--- a/calendar/backends/http/e-cal-backend-http.c
+++ b/calendar/backends/http/e-cal-backend-http.c
@@ -968,6 +968,8 @@ e_cal_backend_http_init (ECalBackendHttp *cbhttp, ECalBackendHttpClass *class)
        priv->uri = NULL;
        priv->reload_timeout_id = 0;
        priv->opened = FALSE;
+
+       e_cal_backend_sync_set_lock (E_CAL_BACKEND_SYNC (cbhttp), TRUE);
 }
 
 /* Class initialization function for the file backend */

diff --git a/calendar/backends/weather/e-cal-backend-weather.c b/calendar/backends/weather/e-cal-backend-weather.c
index f540772..78af660 100644 (file)
--- a/calendar/backends/weather/e-cal-backend-weather.c
+++ b/calendar/backends/weather/e-cal-backend-weather.c
@@ -829,6 +829,8 @@ e_cal_backend_weather_init (ECalBackendWeather *cbw, ECalBackendWeatherClass *cl
        priv->city = NULL;
 
        priv->zones = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, free_zone);
+
+       e_cal_backend_sync_set_lock (E_CAL_BACKEND_SYNC (cbw), TRUE);
 }
 
 /* Class initialization function for the weather backend */

diff --git a/calendar/libedata-cal/e-cal-backend-sync.c b/calendar/libedata-cal/e-cal-backend-sync.c
index bf6c42b..8517153 100644 (file)
--- a/calendar/libedata-cal/e-cal-backend-sync.c
+++ b/calendar/libedata-cal/e-cal-backend-sync.c
@@ -13,83 +13,104 @@
 #include "e-cal-backend-sync.h"
 
 struct _ECalBackendSyncPrivate {
-       int mumble;
        GMutex *sync_mutex;
+
+       gboolean mutex_lock;
 };
 
+#define LOCK_WRAPPER(func, args) \
+  g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->func); \
+  if (backend->priv->mutex_lock) \
+    g_mutex_lock (backend->priv->sync_mutex); \
+  status = (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->func) args; \
+  if (backend->priv->mutex_lock) \
+    g_mutex_unlock (backend->priv->sync_mutex); \
+  return status;
+
 static GObjectClass *parent_class;
 
+void
+e_cal_backend_sync_set_lock (ECalBackendSync *backend, gboolean lock)
+{
+       g_return_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend));
+
+       backend->priv->mutex_lock = lock;
+}
+
 ECalBackendSyncStatus
 e_cal_backend_sync_is_read_only  (ECalBackendSync *backend, EDataCal *cal, gboolean *read_only)
 {
+       ECalBackendSyncStatus status;
+
        g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
        g_return_val_if_fail (read_only, GNOME_Evolution_Calendar_OtherError);
 
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->is_read_only_sync);
+       LOCK_WRAPPER (is_read_only_sync, (backend, cal, read_only));
 
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->is_read_only_sync) (backend, cal, read_only);
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_cal_address  (ECalBackendSync *backend, EDataCal *cal, char **address)
 {
+       ECalBackendSyncStatus status;
+
        g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
        g_return_val_if_fail (address, GNOME_Evolution_Calendar_OtherError);
 
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_cal_address_sync);
+       LOCK_WRAPPER (get_cal_address_sync, (backend, cal, address));
 
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_cal_address_sync) (backend, cal, address);
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_alarm_email_address  (ECalBackendSync *backend, EDataCal *cal, char **address)
 {
+       ECalBackendSyncStatus status;
+
        g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
        g_return_val_if_fail (address, GNOME_Evolution_Calendar_OtherError);
 
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_alarm_email_address_sync);
+       LOCK_WRAPPER (get_alarm_email_address_sync, (backend, cal, address));
 
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_alarm_email_address_sync) (backend, cal, address);
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_ldap_attribute  (ECalBackendSync *backend, EDataCal *cal, char **attribute)
 {
+       ECalBackendSyncStatus status;
+
        g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
        g_return_val_if_fail (attribute, GNOME_Evolution_Calendar_OtherError);
 
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_ldap_attribute_sync);
+       LOCK_WRAPPER (get_ldap_attribute_sync, (backend, cal, attribute));
 
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_ldap_attribute_sync) (backend, cal, attribute);
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_static_capabilities  (ECalBackendSync *backend, EDataCal *cal, char **capabilities)
 {
+       ECalBackendSyncStatus status;
+
        g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
        g_return_val_if_fail (capabilities, GNOME_Evolution_Calendar_OtherError);
 
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_static_capabilities_sync);
+       LOCK_WRAPPER (get_static_capabilities_sync, (backend, cal, capabilities));
 
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_static_capabilities_sync) (backend, cal, capabilities);
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_open  (ECalBackendSync *backend, EDataCal *cal, gboolean only_if_exists,
                          const char *username, const char *password)
 {
-       ECalBackendSyncPrivate *priv;
        ECalBackendSyncStatus status;
        
        g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->open_sync);
-       priv = backend->priv;
-
-       g_mutex_lock (priv->sync_mutex);
-
-       status = (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->open_sync) (backend, cal, only_if_exists, username, password);
 
-       g_mutex_unlock (priv->sync_mutex);
+       LOCK_WRAPPER (open_sync, (backend, cal, only_if_exists, username, password));
 
        return status;
 }
@@ -97,139 +118,175 @@ e_cal_backend_sync_open  (ECalBackendSync *backend, EDataCal *cal, gboolean only
 ECalBackendSyncStatus
 e_cal_backend_sync_remove  (ECalBackendSync *backend, EDataCal *cal)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->remove_sync);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->remove_sync) (backend, cal);
+       ECalBackendSyncStatus status;
+  
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+  
+       LOCK_WRAPPER (remove_sync, (backend, cal));
+       
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_create_object (ECalBackendSync *backend, EDataCal *cal, char **calobj, char **uid)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->create_object_sync != NULL,
-                             GNOME_Evolution_Calendar_UnsupportedMethod);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->create_object_sync) (backend, cal, calobj, uid);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->create_object_sync != NULL,
+                             GNOME_Evolution_Calendar_UnsupportedMethod);
+  
+       LOCK_WRAPPER (create_object_sync, (backend, cal, calobj, uid));
+ 
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_modify_object (ECalBackendSync *backend, EDataCal *cal, const char *calobj, 
                                  CalObjModType mod, char **old_object, char **new_object)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->modify_object_sync != NULL,
-                             GNOME_Evolution_Calendar_UnsupportedMethod);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->modify_object_sync) (backend, cal, 
-                                                                            calobj, mod, old_object, new_object);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->modify_object_sync != NULL,
+                             GNOME_Evolution_Calendar_UnsupportedMethod);
+  
+       LOCK_WRAPPER (modify_object_sync, (backend, cal, calobj, mod, old_object, new_object));
+ 
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_remove_object (ECalBackendSync *backend, EDataCal *cal, const char *uid, const char *rid,
                                  CalObjModType mod, char **old_object, char **object)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->remove_object_sync != NULL,
-                             GNOME_Evolution_Calendar_UnsupportedMethod);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->remove_object_sync) (backend, cal, uid, rid, mod,
-                                                                              old_object, object);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->remove_object_sync != NULL,
+                             GNOME_Evolution_Calendar_UnsupportedMethod);
+  
+       LOCK_WRAPPER (remove_object_sync, (backend, cal, uid, rid, mod, old_object, object));
+ 
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_discard_alarm (ECalBackendSync *backend, EDataCal *cal, const char *uid, const char *auid)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->discard_alarm_sync != NULL,
-                             GNOME_Evolution_Calendar_UnsupportedMethod);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->discard_alarm_sync) (backend, cal, uid, auid);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->discard_alarm_sync != NULL,
+                             GNOME_Evolution_Calendar_UnsupportedMethod);
+  
+       LOCK_WRAPPER (discard_alarm_sync, (backend, cal, uid, auid));
+ 
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_receive_objects (ECalBackendSync *backend, EDataCal *cal, const char *calobj)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->receive_objects_sync != NULL,
-                             GNOME_Evolution_Calendar_UnsupportedMethod);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->receive_objects_sync) (backend, cal, calobj);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->receive_objects_sync != NULL,
+                             GNOME_Evolution_Calendar_UnsupportedMethod);
+  
+       LOCK_WRAPPER (receive_objects_sync, (backend, cal, calobj));
+ 
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_send_objects (ECalBackendSync *backend, EDataCal *cal, const char *calobj, GList **users,
                                 char **modified_calobj)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->send_objects_sync != NULL,
-                             GNOME_Evolution_Calendar_UnsupportedMethod);
-       
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->send_objects_sync) (backend, cal, calobj, users, modified_calobj);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->send_objects_sync != NULL,
+                             GNOME_Evolution_Calendar_UnsupportedMethod);
+ 
+       LOCK_WRAPPER (send_objects_sync, (backend, cal, calobj, users, modified_calobj));
+ 
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_default_object (ECalBackendSync *backend, EDataCal *cal, char **object)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
-
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_default_object_sync);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_default_object_sync) (backend, cal, object);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
+  
+       LOCK_WRAPPER (get_default_object_sync, (backend, cal, object));
+  
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_object (ECalBackendSync *backend, EDataCal *cal, const char *uid, const char *rid, char **object)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
-
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_object_sync);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_object_sync) (backend, cal, uid, rid, object);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (object, GNOME_Evolution_Calendar_OtherError);
+  
+       LOCK_WRAPPER (get_object_sync, (backend, cal, uid, rid, object));
+  
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_object_list (ECalBackendSync *backend, EDataCal *cal, const char *sexp, GList **objects)
 {
-       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-       g_return_val_if_fail (objects, GNOME_Evolution_Calendar_OtherError);
-
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_object_list_sync);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_object_list_sync) (backend, cal, sexp, objects);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (backend && E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+       g_return_val_if_fail (objects, GNOME_Evolution_Calendar_OtherError);
+  
+       LOCK_WRAPPER (get_object_list_sync, (backend, cal, sexp, objects));
+  
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_timezone (ECalBackendSync *backend, EDataCal *cal, const char *tzid, char **object)
 {
-       g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_timezone_sync != NULL);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_timezone_sync) (backend, cal, tzid, object);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+  
+       LOCK_WRAPPER (get_timezone_sync, (backend, cal, tzid, object));
+  
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_add_timezone (ECalBackendSync *backend, EDataCal *cal, const char *tzobj)
 {
-       g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->add_timezone_sync != NULL);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->add_timezone_sync) (backend, cal, tzobj);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+  
+       LOCK_WRAPPER (add_timezone_sync, (backend, cal, tzobj));
+  
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_set_default_timezone (ECalBackendSync *backend, EDataCal *cal, const char *tzid)
 {
-       g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
-
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->set_default_timezone_sync != NULL);
-
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->set_default_timezone_sync) (backend, cal, tzid);
+       ECalBackendSyncStatus status;
+ 
+       g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
+  
+       LOCK_WRAPPER (set_default_timezone_sync, (backend, cal, tzid));
+  
+       return status;
 }
 
 
@@ -237,24 +294,26 @@ ECalBackendSyncStatus
 e_cal_backend_sync_get_changes (ECalBackendSync *backend, EDataCal *cal, const char *change_id,
                              GList **adds, GList **modifies, GList **deletes)
 {
+       ECalBackendSyncStatus status;
+
        g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
 
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_changes_sync != NULL);
+       LOCK_WRAPPER (get_changes_sync, (backend, cal, change_id, adds, modifies, deletes));
 
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_changes_sync) (backend, cal, change_id, 
-                                                                          adds, modifies, deletes);
+       return status;
 }
 
 ECalBackendSyncStatus
 e_cal_backend_sync_get_free_busy (ECalBackendSync *backend, EDataCal *cal, GList *users, 
                                time_t start, time_t end, GList **freebusy)
 {
+       ECalBackendSyncStatus status;
+
        g_return_val_if_fail (E_IS_CAL_BACKEND_SYNC (backend), GNOME_Evolution_Calendar_OtherError);
 
-       g_assert (E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_freebusy_sync != NULL);
+       LOCK_WRAPPER (get_freebusy_sync, (backend, cal, users, start, end, freebusy));
 
-       return (* E_CAL_BACKEND_SYNC_GET_CLASS (backend)->get_freebusy_sync) (backend, cal, users, 
-                                                                           start, end, freebusy);
+       return status;
 }
 
 

diff --git a/calendar/libedata-cal/e-cal-backend-sync.h b/calendar/libedata-cal/e-cal-backend-sync.h
index fd8a156..a19af13 100644 (file)
--- a/calendar/libedata-cal/e-cal-backend-sync.h
+++ b/calendar/libedata-cal/e-cal-backend-sync.h
@@ -74,6 +74,8 @@ struct _ECalBackendSyncClass {
 
 typedef ECalBackendSync * (*ECalBackendSyncFactoryFn) (void);
 GType                e_cal_backend_sync_get_type                (void);
+void e_cal_backend_sync_set_lock (ECalBackendSync  *backend, gboolean lock);
+
 ECalBackendSyncStatus e_cal_backend_sync_is_read_only            (ECalBackendSync  *backend,
                                                               EDataCal             *cal,
                                                               gboolean        *read_only);

diff --git a/calendar/tests/ecal/test-recur.c b/calendar/tests/ecal/test-recur.c
index 41b5422..3250983 100644 (file)
--- a/calendar/tests/ecal/test-recur.c
+++ b/calendar/tests/ecal/test-recur.c
@@ -13,8 +13,8 @@ main (int argc, char **argv)
        if (bonobo_init (&argc, argv) == FALSE)
                g_error ("Could not initialize Bonobo");
 
-       if (argc < 3) {
-               printf ("usage: test-search <uid> <query>\n");
+       if (argc < 2) {
+               printf ("usage: test-recur <uid>\n");
                exit (0);
        }
 
@@ -25,25 +25,6 @@ main (int argc, char **argv)
                exit(0);
        }
 
-       if (!e_cal_get_object_list_as_comp (ecal, argv[2], &objects, NULL)) {
-               printf ("failed to get objects\n");
-               exit(0);
-       }
-
-       printf ("Received %d objects\n", g_list_length (objects));
-       for (l = objects; l; l = l->next) {
-               ECalComponent *comp = E_CAL_COMPONENT (l->data);
-               char *str;
-               
-               str = e_cal_component_get_as_string (comp);
-               printf ("%s\n", str);
-
-               g_free (str);
-               g_object_unref (comp);
-       }
-
-       g_list_free (objects);
-
        g_object_unref (ecal);
 
        return 0;