wrapper/opensync-group.i

   1 typedef struct {} GroupEnv;
   2 %extend GroupEnv {
   3         GroupEnv() {
   4                 Error *err = NULL;
   5                 GroupEnv *env = osync_group_env_new(&err);
   6                 if (raise_exception_on_error(err))
   7                         return NULL;
   8                 else
   9                         return env;
  10         }
  11
  12         ~GroupEnv() {
  13                 osync_group_env_free(self);
  14         }
  15
  16         void load_groups(const char *path = NULL) {
  17                 Error *err = NULL;
  18                 bool ret = osync_group_env_load_groups(self, path, &err);
  19                 if (!raise_exception_on_error(err) && !ret)
  20                         wrapper_exception("osync_group_env_load_groups failed but did not set error code");
  21         }
  22
  23         Group *find_group(const char *name) {
  24                 Group *group = osync_group_env_find_group(self, name);
  25                 if (group)
  26                         osync_group_ref(group);
  27                 return group;
  28         }
  29
  30         void add_group(Group *group) {
  31                 Error *err = NULL;
  32                 bool ret = osync_group_env_add_group(self, group, &err);
  33                 if (!raise_exception_on_error(err) && !ret)
  34                         wrapper_exception("osync_group_env_add_group failed but did not set error code");
  35         }
  36
  37         void remove_group(Group *group) {
  38                 osync_group_env_remove_group(self, group);
  39         }
  40
  41         int num_groups() {
  42                 return osync_group_env_num_groups(self);
  43         }
  44
  45         Group *nth_group(int nth) {
  46                 Group *group = osync_group_env_nth_group(self, nth);
  47                 if (group)
  48                         osync_group_ref(group);
  49                 return group;
  50         }
  51
  52 %pythoncode %{
  53         # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
  54         __oldinit = __init__
  55         def __init__(self, *args):
  56                 self.__oldinit(*args)
  57                 self.groups = _ListWrapper(self.num_groups, self.nth_group)
  58 %}
  59 }
  60
  61 enum LockState {};
  62 %constant int LOCK_OK = OSYNC_LOCK_OK;
  63 %constant int LOCKED = OSYNC_LOCKED;
  64 %constant int LOCK_STALE = OSYNC_LOCK_STALE;
  65
  66 enum ConflictResolution ();
  67 %constant int CONFLICT_RESOLUTION_UNKNOWN = OSYNC_CONFLICT_RESOLUTION_UNKNOWN;
  68 %constant int CONFLICT_RESOLUTION_DUPLICATE = OSYNC_CONFLICT_RESOLUTION_DUPLICATE;
  69 %constant int CONFLICT_RESOLUTION_IGNORE = OSYNC_CONFLICT_RESOLUTION_IGNORE;
  70 %constant int CONFLICT_RESOLUTION_NEWER = OSYNC_CONFLICT_RESOLUTION_NEWER;
  71 %constant int CONFLICT_RESOLUTION_SELECT = OSYNC_CONFLICT_RESOLUTION_SELECT;
  72
  73 typedef struct {} Group;
  74 %extend Group {
  75         Group() {
  76                 Error *err = NULL;
  77                 Group *group = osync_group_new(&err);
  78                 if (raise_exception_on_error(err))
  79                         return NULL;
  80                 else
  81                         return group;
  82         }
  83
  84         ~Group() {
  85                 osync_group_unref(self);
  86         }
  87
  88         LockState lock() {
  89                 return osync_group_lock(self);
  90         }
  91
  92         void unlock() {
  93                 osync_group_unlock(self);
  94         }
  95
  96         void set_name(const char *name) {
  97                 osync_group_set_name(self, name);
  98         }
  99
 100         const char *get_name() {
 101                 return osync_group_get_name(self);
 102         }
 103
 104         void save() {
 105                 Error *err = NULL;
 106                 bool ret = osync_group_save(self, &err);
 107                 if (!raise_exception_on_error(err) && !ret)
 108                         wrapper_exception("osync_group_save failed but did not set error code");
 109         }
 110
 111         void delete() {
 112                 Error *err = NULL;
 113                 bool ret = osync_group_delete(self, &err);
 114                 if (!raise_exception_on_error(err) && !ret)
 115                         wrapper_exception("osync_group_delete failed but did not set error code");
 116         }
 117
 118         void reset() {
 119                 Error *err = NULL;
 120                 bool ret = osync_group_reset(self, &err);
 121                 if (!raise_exception_on_error(err) && !ret)
 122                         wrapper_exception("osync_group_reset failed but did not set error code");
 123         }
 124
 125         void load(const char *path) {
 126                 Error *err = NULL;
 127                 bool ret = osync_group_load(self, path, &err);
 128                 if (!raise_exception_on_error(err) && !ret)
 129                         wrapper_exception("osync_group_load failed but did not set error code");
 130         }
 131
 132         void add_member(Member *member) {
 133                 osync_group_add_member(self, member);
 134         }
 135
 136         void remove_member(Member *member) {
 137                 osync_group_remove_member(self, member);
 138         }
 139
 140         Member *find_member(int id) {
 141                 Member *member = osync_group_find_member(self, id);
 142                 if (member)
 143                         osync_member_ref(member);
 144         return member;
 145         }
 146
 147         Member *nth_member(int nth) {
 148                 Member *member = osync_group_nth_member(self, nth);
 149                 if (member)
 150                         osync_member_ref(member);
 151         return member;
 152         }
 153
 154         int num_members() {
 155                 return osync_group_num_members(self);
 156         }
 157
 158         const char *get_configdir() {
 159                 return osync_group_get_configdir(self);
 160         }
 161
 162         void set_configdir(const char *directory) {
 163                 osync_group_set_configdir(self, directory);
 164         }
 165
 166         int num_objtypes() {
 167                 return osync_group_num_objtypes(self);
 168         }
 169
 170         const char *nth_objtype(int nth) {
 171                 return osync_group_nth_objtype(self, nth);
 172         }
 173
 174         void set_objtype_enabled(const char *objtype, bool enabled) {
 175                 osync_group_set_objtype_enabled(self, objtype, enabled);
 176         }
 177
 178         int objtype_enabled(const char *objtype) {
 179                 return osync_group_objtype_enabled(self, objtype);
 180         }
 181
 182         /*
 183         void add_filter(Filter *filter) {
 184                 osync_group_add_filter(self, filter);
 185         }
 186
 187         void remove_filter(Filter *filter) {
 188                 osync_group_remove_filter(self, filter);
 189         }
 190
 191         int num_filters() {
 192                 return osync_group_num_filters(self);
 193         }
 194
 195         Filter *nth_filter(int nth) {
 196                 Filter *filter = osync_group_nth_filter(self, nth);
 197                 if (filter)
 198                         osync_filter_ref(filter);
 199                 return filter;
 200         }
 201         */
 202
 203         void set_last_synchronization(time_t last_sync) {
 204                 osync_group_set_last_synchronization(self, last_sync);
 205         }
 206
 207         time_t get_last_synchronization() {
 208                 return osync_group_get_last_synchronization(self);
 209         }
 210
 211         void set_conflict_resolution(ConflictResolution res, int num) {
 212                 osync_group_set_conflict_resolution(self, res, num);
 213         }
 214
 215         %apply ConflictResolution *OUTPUT { ConflictResolution *res, int *num };
 216         %apply int *OUTPUT { ConflictResolution *res, int *num };
 217         void get_conflict_resolution(ConflictResolution *res, int *num) {
 218                 osync_group_get_conflict_resolution(self, res, num);
 219         }
 220
 221         bool get_merger_enabled() {
 222                 return osync_group_get_merger_enabled(self);
 223         }
 224
 225         void set_merger_enabled(bool enable_merger) {
 226                 osync_group_set_merger_enabled(self, enable_merger);
 227         }
 228
 229         bool get_converter_enabled() {
 230                 return osync_group_get_converter_enabled(self);
 231         }
 232
 233         void set_converter_enabled(bool enable_converter) {
 234                 osync_group_set_converter_enabled(self, enable_converter);
 235         }
 236
 237 %pythoncode %{
 238         name = property(get_name, set_name)
 239         configdir = property(get_configdir, set_configdir)
 240         last_synchronization = property(get_last_synchronization, set_last_synchronization)
 241         merger_enabled = property(get_merger_enabled, set_merger_enabled)
 242         converter_enabled = property(get_converter_enabled, set_converter_enabled)
 243
 244         # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
 245         __oldinit = __init__
 246         def __init__(self, *args):
 247                 self.__oldinit(*args)
 248                 self.members = _ListWrapper(self.num_members, self.nth_member)
 249                 self.objtypes = _ListWrapper(self.num_objtypes, self.nth_objtype)
 250                 /*
 251                 self.filters = _ListWrapper(self.num_filters, self.nth_filter)
 252                 */
 253 %}
 254 }
 255
 256
 257 typedef enum {} StartType;
 258
 259 %constant int START_TYPE_UNKNOWN = OSYNC_START_TYPE_UNKNOWN;
 260 %constant int START_TYPE_PROCESS = OSYNC_START_TYPE_PROCESS;
 261 %constant int START_TYPE_THREAD = OSYNC_START_TYPE_THREAD;
 262 %constant int START_TYPE_EXTERNAL = OSYNC_START_TYPE_EXTERNAL;
 263
 264
 265 typedef struct {} Member;
 266 %extend Member {
 267         Member() {
 268                 Error *err = NULL;
 269                 Member *member = osync_member_new(&err);
 270                 if (raise_exception_on_error(err))
 271                         return NULL;
 272                 else
 273                         return member;
 274         }
 275
 276         ~Member() {
 277                 osync_member_unref(self);
 278         }
 279
 280         const char *get_pluginname() {
 281                 return osync_member_get_pluginname(self);
 282         }
 283
 284         void set_pluginname(const char *pluginname) {
 285                 osync_member_set_pluginname(self, pluginname);
 286         }
 287
 288         const char *get_name() {
 289                 return osync_member_get_name(self);
 290         }
 291
 292         void set_name(const char *name) {
 293                 osync_member_set_name(self, name);
 294         }
 295
 296         const char *get_configdir() {
 297                 return osync_member_get_configdir(self);
 298         }
 299
 300         void set_configdir(const char *configdir) {
 301                 osync_member_set_configdir(self, configdir);
 302         }
 303
 304         PluginConfig *get_config_or_default() {
 305                 Error *err = NULL;
 306                 PluginConfig *ret = osync_member_get_config_or_default(self, &err);
 307                 if (raise_exception_on_error(err))
 308                         return NULL;
 309                 else
 310                         return ret;
 311         }
 312
 313         bool has_config() {
 314                 return osync_member_has_config(self);
 315         }
 316
 317         PluginConfig *get_config() {
 318                 Error *err = NULL;
 319                 PluginConfig *ret = osync_member_get_config(self, &err);
 320                 if (raise_exception_on_error(err))
 321                         return NULL;
 322                 else
 323                         return ret;
 324         }
 325
 326         void set_config(PluginConfig *data) {
 327                 osync_member_set_config(self, data);
 328         }
 329
 330         void load(const char *path) {
 331                 Error *err = NULL;
 332                 bool ret = osync_member_load(self, path, &err);
 333                 if (!raise_exception_on_error(err) && !ret)
 334                         wrapper_exception("osync_member_load failed but did not set error code");
 335         }
 336
 337         void save() {
 338                 Error *err = NULL;
 339                 bool ret = osync_member_save(self, &err);
 340                 if (!raise_exception_on_error(err) && !ret)
 341                         wrapper_exception("osync_member_save failed but did not set error code");
 342         }
 343
 344         void delete() {
 345                 Error *err = NULL;
 346                 bool ret = osync_member_delete(self, &err);
 347                 if (!raise_exception_on_error(err) && !ret)
 348                         wrapper_exception("osync_member_delete failed but did not set error code");
 349         }
 350
 351         long long int get_id() {
 352                 return osync_member_get_id(self);
 353         }
 354
 355         void add_objformat(const char *objtype, const char *format) {
 356                 osync_member_add_objformat(self, objtype, format);
 357         }
 358
 359         /* returns a list of strings */
 360         PyObject *get_objformats(const char *objtype) {
 361                 Error *err = NULL;
 362                 const OSyncList *list = osync_member_get_objformats(self, objtype, &err);
 363                 if (raise_exception_on_error(err) || list == NULL)
 364                         return NULL;
 365
 366                 return osynclist_to_pylist(list, SWIGTYPE_p_char);
 367         }
 368
 369         void add_objtype_sink(ObjTypeSink *sink) {
 370                 osync_member_add_objtype_sink(self, sink);
 371         }
 372
 373         int num_objtypes() {
 374                 return osync_member_num_objtypes(self);
 375         }
 376
 377         const char *nth_objtype(int nth) {
 378                 return osync_member_nth_objtype(self, nth);
 379         }
 380
 381         bool objtype_enabled(const char *objtype) {
 382                 return osync_member_objtype_enabled(self, objtype);
 383         }
 384
 385         void set_objtype_enabled(const char *objtype, bool enabled) {
 386                 osync_member_set_objtype_enabled(self, objtype, enabled);
 387         }
 388
 389         Capabilities *get_capabilities() {
 390                 Capabilities *caps = osync_member_get_capabilities(self);
 391                 if (caps)
 392                         osync_capabilities_ref(caps);
 393                 return caps;
 394         }
 395
 396         void set_capabilities(Capabilities *capabilities) {
 397                 Error *err = NULL;
 398                 bool ret = osync_member_set_capabilities(self, capabilities, &err);
 399                 if (!raise_exception_on_error(err) && !ret)
 400                         wrapper_exception("osync_member_set_capabilities failed but did not set error code");
 401         }
 402
 403         Merger *get_merger() {
 404                 Merger *merger = osync_member_get_merger(self);
 405                 if (merger)
 406                         osync_merger_ref(merger);
 407                 return merger;
 408         }
 409
 410         void flush_objtypes() {
 411                 osync_member_flush_objtypes(self);
 412         }
 413
 414 %pythoncode %{
 415         pluginname = property(get_pluginname, set_pluginname)
 416         name = property(get_name, set_name)
 417         configdir = property(get_configdir, set_configdir)
 418         config = property(get_config, set_config)
 419         id = property(get_id)
 420         capabilities = property(get_capabilities, set_capabilities)
 421         merger = property(get_merger)
 422
 423         # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
 424         __oldinit = __init__
 425         def __init__(self, *args):
 426                 self.__oldinit(*args)
 427                 self.objtypes = _ListWrapper(self.num_objtypes, self.nth_objtype)
 428 %}
 429 }