## ECalBackendSync

ECalBackendSync — A convenience subclass of ECalBackend

## Synopsis

    #include <libedata-cal/libedata-cal.h>

    struct              ECalBackendSync;
    struct              ECalBackendSyncClass;
    void                e_cal_backend_sync_open             (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             gboolean only_if_exists,
                                                             GError **error);
    void                e_cal_backend_sync_refresh          (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_sync_get_object       (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             gchar **calobj,
                                                             GError **error);
    void                e_cal_backend_sync_get_object_list  (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *sexp,
                                                             GSList **calobjs,
                                                             GError **error);
    void                e_cal_backend_sync_get_free_busy    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *users,
                                                             time_t start,
                                                             time_t end,
                                                             GSList **freebusyobjects,
                                                             GError **error);
    void                e_cal_backend_sync_create_objects   (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *calobjs,
                                                             GSList **uids,
                                                             GSList **new_components,
                                                             GError **error);
    void                e_cal_backend_sync_modify_objects   (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *calobjs,
                                                             ECalObjModType mod,
                                                             GSList **old_components,
                                                             GSList **new_components,
                                                             GError **error);
    void                e_cal_backend_sync_remove_objects   (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *ids,
                                                             ECalObjModType mod,
                                                             GSList **old_components,
                                                             GSList **new_components,
                                                             GError **error);
    void                e_cal_backend_sync_receive_objects  (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             GError **error);
    void                e_cal_backend_sync_send_objects     (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             GSList **users,
                                                             gchar **modified_calobj,
                                                             GError **error);
    void                e_cal_backend_sync_get_attachment_uris
                                                            (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GSList **attachments,
                                                             GError **error);
    void                e_cal_backend_sync_discard_alarm    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             const gchar *auid,
                                                             GError **error);
    void                e_cal_backend_sync_get_timezone     (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *tzid,
                                                             gchar **tzobject,
                                                             GError **error);
    void                e_cal_backend_sync_add_timezone     (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *tzobject,
                                                             GError **error);

## Description

This class can be subclassed in place of the ECalBackend abstract backend for easier implementation of calendar backends.

## Details

### struct ECalBackendSync

    struct ECalBackendSync {
    	ECalBackend parent;
    	ECalBackendSyncPrivate *priv;
    };

### struct ECalBackendSyncClass

    struct ECalBackendSyncClass {
    	ECalBackendClass parent_class;

    	/* Virtual methods */
    	void		(*open_sync)		(ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 gboolean only_if_exists,
    						 GError **error);
    	void		(*refresh_sync)		(ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 GError **error);

    	/* This method is deprecated. */
    	gboolean (*set_backend_property_sync)
    						(ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *prop_name,
    						 const gchar *prop_value,
    						 GError **error);

    	void		(*get_object_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *uid,
    						 const gchar *rid,
    						 gchar **calobj,
    						 GError **error);
    	void		(*get_object_list_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *sexp,
    						 GSList **calobjs,
    						 GError **error);
    	void		(*get_free_busy_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const GSList *users,
    						 time_t start,
    						 time_t end,
    						 GSList **freebusyobjs,
    						 GError **error);
    	void		(*create_objects_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const GSList *calobjs,
    						 GSList **uids,
    						 GSList **new_components,
    						 GError **error);
    	void		(*modify_objects_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const GSList *calobjs,
    						 ECalObjModType mod,
    						 GSList **old_components,
    						 GSList **new_components,
    						 GError **error);
    	void		(*remove_objects_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const GSList *ids,
    						 ECalObjModType mod,
    						 GSList **old_components,
    						 GSList **new_components,
    						 GError **error);
    	void		(*receive_objects_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *calobj,
    						 GError **error);
    	void		(*send_objects_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *calobj,
    						 GSList **users,
    						 gchar **modified_calobj,
    						 GError **error);
    	void		(*get_attachment_uris_sync)
    						(ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *uid,
    						 const gchar *rid,
    						 GSList **attachments,
    						 GError **error);
    	void		(*discard_alarm_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *uid,
    						 const gchar *rid,
    						 const gchar *auid,
    						 GError **error);
    	void		(*get_timezone_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *tzid,
    						 gchar **tzobject,
    						 GError **error);
    	void		(*add_timezone_sync) (ECalBackendSync *backend,
    						 EDataCal *cal,
    						 GCancellable *cancellable,
    						 const gchar *tzobject,
    						 GError **error);
    };

### e_cal_backend_sync_open ()

    void                e_cal_backend_sync_open             (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             gboolean only_if_exists,
                                                             GError **error);

Calls the open_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`only_if_exists` : | Whether to open the calendar if and only if it already exists or just create it when it does not exist.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_refresh ()

    void                e_cal_backend_sync_refresh          (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             GError **error);

Calls the refresh_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`error` : | Out parameter for a GError.

Since 2.30

### e_cal_backend_sync_get_object ()

    void                e_cal_backend_sync_get_object       (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             gchar **calobj,
                                                             GError **error);

Calls the get_object_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`uid` : | UID of the object to get.
`rid` : | Recurrence ID of the specific instance to get, or NULL if getting the master object.
`calobj` : | Placeholder for returned object.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_get_object_list ()

    void                e_cal_backend_sync_get_object_list  (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *sexp,
                                                             GSList **calobjs,
                                                             GError **error);

Calls the get_object_list_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`sexp` : | Search query.
`calobjs` : | Placeholder for list of returned objects.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_get_free_busy ()

    void                e_cal_backend_sync_get_free_busy    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *users,
                                                             time_t start,
                                                             time_t end,
                                                             GSList **freebusyobjects,
                                                             GError **error);

Calls the get_free_busy_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`users` : | List of users to get F/B info from.
`start` : | Time range start.
`end` : | Time range end.
`freebusyobjects` : | Placeholder for F/B information.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_create_objects ()

    void                e_cal_backend_sync_create_objects   (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *calobjs,
                                                             GSList **uids,
                                                             GSList **new_components,
                                                             GError **error);

Calls the create_objects_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`calobjs` : | The objects to be added.
`uids` : | Placeholder for server-generated UIDs.
`new_components` : | Placeholder for returned ECalComponent objects. [out][transfer full]
`error` : | Out parameter for a GError.

Since 3.6

### e_cal_backend_sync_modify_objects ()

    void                e_cal_backend_sync_modify_objects   (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *calobjs,
                                                             ECalObjModType mod,
                                                             GSList **old_components,
                                                             GSList **new_components,
                                                             GError **error);

Calls the modify_objects_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`calobjs` : | Objects to be modified.
`mod` : | Type of modification to be done.
`old_components` : | Placeholder for returning the old components as they were stored on the backend. [out][transfer full]
`new_components` : | Placeholder for returning the new components as they have been stored on the backend. [out][transfer full]
`error` : | Out parameter for a GError.

Since 3.6

### e_cal_backend_sync_remove_objects ()

    void                e_cal_backend_sync_remove_objects   (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *ids,
                                                             ECalObjModType mod,
                                                             GSList **old_components,
                                                             GSList **new_components,
                                                             GError **error);

Calls the remove_objects_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`ids` : | List of ECalComponentId objects identifying the objects to remove.
`mod` : | Type of removal.
`old_components` : | Placeholder for returning the old components as they were stored on the backend. [out][transfer full]
`new_components` : | Placeholder for returning the new components as they have been stored on the backend (when removing individual instances). If removing whole objects, they will be set to `NULL`. [out][transfer full]
`error` : | Out parameter for a GError.

Since 3.6

### e_cal_backend_sync_receive_objects ()

    void                e_cal_backend_sync_receive_objects  (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             GError **error);

Calls the receive_objects_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`calobj` : | iCalendar object to receive.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_send_objects ()

    void                e_cal_backend_sync_send_objects     (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             GSList **users,
                                                             gchar **modified_calobj,
                                                             GError **error);

Calls the send_objects_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`calobj` : | The iCalendar object to send.
`users` : | List of users to send notifications to.
`modified_calobj` : | Placeholder for the iCalendar object after being modified.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_get_attachment_uris ()

    void                e_cal_backend_sync_get_attachment_uris
                                                            (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             GSList **attachments,
                                                             GError **error);

Calls the get_attachment_uris_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`uid` : | Unique id of the calendar object.
`rid` : | Recurrence id of the calendar object.
`attachments` : | Placeholder for list of returned attachment uris.
`error` : | Out parameter for a GError.

Since 3.2

### e_cal_backend_sync_discard_alarm ()

    void                e_cal_backend_sync_discard_alarm    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             const gchar *auid,
                                                             GError **error);

Calls the discard_alarm_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`uid` : | Unique id of the calendar object.
`rid` : | Recurrence id of the calendar object.
`auid` : | Alarm ID to remove.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_get_timezone ()

    void                e_cal_backend_sync_get_timezone     (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *tzid,
                                                             gchar **tzobject,
                                                             GError **error);

Calls the get_timezone_sync method on the given backend. This method is not mandatory on the backend, because here is used internal_get_timezone call to fetch timezone from it and that is transformed to a string. In other words, any object deriving from ECalBackendSync can implement only internal_get_timezone and can skip implementation of get_timezone_sync completely.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`tzid` : | ID of the timezone to retrieve.
`tzobject` : | Placeholder for the returned timezone.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_add_timezone ()

    void                e_cal_backend_sync_add_timezone     (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *tzobject,
                                                             GError **error);

Calls the add_timezone_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`tzobject` : | VTIMEZONE object to be added.
`error` : | Out parameter for a GError.