## ECalBackendSync

ECalBackendSync — Base class for synchronous backends.

## Synopsis

                        ECalBackendSync;
    void                e_cal_backend_sync_set_lock         (ECalBackendSync *backend,
                                                             gboolean lock);
    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_remove           (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_sync_create_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             gchar **uid,
                                                             gchar **new_object,
                                                             GError **error);
    void                e_cal_backend_sync_modify_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             CalObjModType mod,
                                                             gchar **old_object,
                                                             gchar **new_object,
                                                             GError **error);
    void                e_cal_backend_sync_remove_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             CalObjModType mod,
                                                             gchar **old_object,
                                                             gchar **new_object,
                                                             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_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_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_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);
    void                e_cal_backend_sync_get_free_busy    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const GSList *users,
                                                             time_t start,
                                                             time_t end,
                                                             GSList **freebusyobjs,
                                                             GError **error);

## Object Hierarchy

      GObject
       +----ECalBackend
             +----ECalBackendSync

## Description

## Details

### ECalBackendSync

    typedef struct _ECalBackendSync ECalBackendSync;

### e_cal_backend_sync_set_lock ()

    void                e_cal_backend_sync_set_lock         (ECalBackendSync *backend,
                                                             gboolean lock);

Sets the lock mode on the ECalBackendSync object. If TRUE, the backend will create a locking mutex for every operation, so that only one can happen at a time. If FALSE, no lock would be done and many operations can happen at the same time.

`backend` : | An ECalBackendSync object.
`lock` : | Lock mode.

### 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_remove ()

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

Calls the remove_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.

### e_cal_backend_sync_create_object ()

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

Calls the create_object_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`calobj` : | The object to be added.
`uid` : | Placeholder for server-generated UID.
`new_object` : | Placeholder for server-calobj, if it changed. Can be left as is if it's same as `calobj`.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_modify_object ()

    void                e_cal_backend_sync_modify_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             CalObjModType mod,
                                                             gchar **old_object,
                                                             gchar **new_object,
                                                             GError **error);

Calls the modify_object_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`calobj` : | Object to be modified.
`mod` : | Type of modification to be done.
`old_object` : | Placeholder for returning the old object as it was stored on the backend.
`new_object` : | Placeholder for returning the new object as it has been stored on the backend.
`error` : | Out parameter for a GError.

### e_cal_backend_sync_remove_object ()

    void                e_cal_backend_sync_remove_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             CalObjModType mod,
                                                             gchar **old_object,
                                                             gchar **new_object,
                                                             GError **error);

Calls the remove_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 remove.
`rid` : | Recurrence ID of the instance to remove, or NULL if removing the whole object.
`mod` : | Type of removal.
`old_object` : | Placeholder for returning the old object as it was stored on the backend.
`new_object` : | Placeholder for returning the object after it has been modified (when removing individual instances). If removing the whole object, this will be NULL.
`error` : | Out parameter for a GError.

### 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_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_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_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.

### 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 **freebusyobjs,
                                                             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.
`freebusyobjs` : |
`error` : | Out parameter for a GError.