## 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_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             gchar **uid,
                                                             icalcomponent **new_component,
                                                             GError **error);
    void                e_cal_backend_sync_modify_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             CalObjModType mod,
                                                             icalcomponent **old_component,
                                                             icalcomponent **new_component,
                                                             GError **error);
    void                e_cal_backend_sync_remove_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *uid,
                                                             const gchar *rid,
                                                             CalObjModType mod,
                                                             icalcomponent **old_component,
                                                             icalcomponent **new_component,
                                                             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);
    void                e_cal_backend_sync_authenticate_user
                                                            (ECalBackendSync *backend,
                                                             GCancellable *cancellable,
                                                             ECredentials *credentials,
                                                             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_object ()

    void                e_cal_backend_sync_create_object    (ECalBackendSync *backend,
                                                             EDataCal *cal,
                                                             GCancellable *cancellable,
                                                             const gchar *calobj,
                                                             gchar **uid,
                                                             icalcomponent **new_component,
                                                             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_component` : | Placeholder for returned icalcomponent. [out][transfer full]
`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,
                                                             icalcomponent **old_component,
                                                             icalcomponent **new_component,
                                                             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_component` : | Placeholder for returning the old component as it was stored on the backend. [out][transfer full]
`new_component` : | Placeholder for returning the new component as it has been stored on the backend. [out][transfer full]
`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,
                                                             icalcomponent **old_component,
                                                             icalcomponent **new_component,
                                                             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_component` : | Placeholder for returning the old component as it was stored on the backend. [out][transfer full]
`new_component` : | Placeholder for returning the new component as it has been stored on the backend (when removing individual instances). If removing the whole object, this will be set to `NULL`. [out][transfer full]
`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_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.

### e_cal_backend_sync_authenticate_user ()

    void                e_cal_backend_sync_authenticate_user
                                                            (ECalBackendSync *backend,
                                                             GCancellable *cancellable,
                                                             ECredentials *credentials,
                                                             GError **error);

Authenticates `backend` with given `credentials`.

`backend` : | an ECalBackendSync
`cancellable` : | a GCancellable for the operation
`credentials` : | an ECredentials to authenticate with
`error` : | GError to set, when something fails

Since 3.2