## ECalBackendSync

ECalBackendSync

## Synopsis

    struct              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_remove           (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                e_cal_backend_sync_refresh          (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             GError **error);
    gboolean            e_cal_backend_sync_get_backend_property
                                                            (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *prop_name,
                                                             gchar **prop_value,
                                                             GError **error);
    gboolean            e_cal_backend_sync_set_backend_property
                                                            (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *prop_name,
                                                             const gchar *prop_value,
                                                             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,
                                                             CalObjModType 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,
                                                             CalObjModType 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);

## Object Hierarchy

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

## Description

## Details

### struct ECalBackendSync

    struct 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_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_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_backend_property ()

    gboolean            e_cal_backend_sync_get_backend_property
                                                            (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *prop_name,
                                                             gchar **prop_value,
                                                             GError **error);

Calls the get_backend_property_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`prop_name` : | Property name whose value to retrieve.
`prop_value` : | Return value of the `prop_name`.
`error` : | Out parameter for a GError.
Returns : | whether processed this property. Returning FALSE means to pass the call to the ECalBackend parent class, thus neither `error` should be set in this case.

Since 3.2

### e_cal_backend_sync_set_backend_property ()

    gboolean            e_cal_backend_sync_set_backend_property
                                                            (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *prop_name,
                                                             const gchar *prop_value,
                                                             GError **error);

Calls the set_backend_property_sync method on the given backend.

`backend` : | An ECalBackendSync object.
`cal` : | An EDataCal object.
`cancellable` : | a GCancellable for the operation
`prop_name` : | Property name to set.
`prop_value` : | New value of the `prop_name`.
`error` : | Out parameter for a GError.
Returns : | whether processed this property. Returning FALSE means to pass the call to the ECalBackend parent class, thus neither `error` should be set in this case.

Since 3.2

### 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,
                                                             CalObjModType 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,
                                                             CalObjModType 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.