python-opensync 0.39-4ubuntu1 / usr / share / pyshared / opensync.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.


"""
Python bindings for the OpenSync library
"""


from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_opensync', [dirname(__file__)])
        except ImportError:
            import _opensync
            return _opensync
        if fp is not None:
            try:
                _mod = imp.load_module('_opensync', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _opensync = swig_import_helper()
    del swig_import_helper
else:
    import _opensync
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


def _swig_setattr_nondynamic_method(set):
    def set_attr(self,name,value):
        if (name == "thisown"): return self.this.own(value)
        if hasattr(self,name) or (name == "this"):
            set(self,name,value)
        else:
            raise AttributeError("You cannot add attributes to %s" % self)
    return set_attr


class _ListWrapper:
	"""Utility class to wrap a common idiom in OpenSync as a Python list."""
	def __init__(self, lenf, getf):
		self.__lenf = lenf
		self.__getf = getf
	
	def __len__(self):
		return self.__lenf()
	
	def __getitem__(self, num):
		if not isinstance(num, int):
			raise TypeError
		if num < 0 or num >= len(self):
			raise IndexError
		return self.__getf(num)

class Error(Exception):
    """Proxy of C Error struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, PyObject obj) -> Error
        __init__(self, char msg, ErrorType type = OSYNC_ERROR_GENERIC) -> Error
        """
        this = _opensync.new_Error(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Error
    __del__ = lambda self : None;
    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.Error_get_name(self)

    def is_set(self):
        """is_set(self) -> bool"""
        return _opensync.Error_is_set(self)

    def get_type(self):
        """get_type(self) -> ErrorType"""
        return _opensync.Error_get_type(self)

    def set_type(self, *args):
        """set_type(self, ErrorType type)"""
        return _opensync.Error_set_type(self, *args)

    def get_msg(self):
        """get_msg(self) -> char"""
        return _opensync.Error_get_msg(self)

    def print_stack(self):
        """print_stack(self) -> char"""
        return _opensync.Error_print_stack(self)

    def set_from_error(self, *args):
        """set_from_error(self, Error source)"""
        return _opensync.Error_set_from_error(self, *args)

    def set(self, *args):
        """set(self, ErrorType type, char msg)"""
        return _opensync.Error_set(self, *args)

    def stack(self, *args):
        """stack(self, Error child)"""
        return _opensync.Error_stack(self, *args)

    def get_child(self):
        """get_child(self) -> Error"""
        return _opensync.Error_get_child(self)

    # for some reason the OpenSync API only allows setting the msg with a type
    def __set_msg(self, msg):
    	self.set(self.num, msg)

    def __str__(self):
    	return self.get_name() + ": " + self.get_msg()

    def report(self, context):
    	"""Report myself as an error to the given Context object."""
    	context.report_osyncerror(self)

    name = property(get_name)
    is_set = property(is_set)
    num = property(get_type, set_type) # 'type' is a reserved word
    msg = property(get_msg, __set_msg)

Error_swigregister = _opensync.Error_swigregister
Error_swigregister(Error)

NO_ERROR = _opensync.NO_ERROR
ERROR_GENERIC = _opensync.ERROR_GENERIC
ERROR_IO_ERROR = _opensync.ERROR_IO_ERROR
ERROR_NOT_SUPPORTED = _opensync.ERROR_NOT_SUPPORTED
ERROR_TIMEOUT = _opensync.ERROR_TIMEOUT
ERROR_DISCONNECTED = _opensync.ERROR_DISCONNECTED
ERROR_FILE_NOT_FOUND = _opensync.ERROR_FILE_NOT_FOUND
ERROR_EXISTS = _opensync.ERROR_EXISTS
ERROR_CONVERT = _opensync.ERROR_CONVERT
ERROR_MISCONFIGURATION = _opensync.ERROR_MISCONFIGURATION
ERROR_INITIALIZATION = _opensync.ERROR_INITIALIZATION
ERROR_PARAMETER = _opensync.ERROR_PARAMETER
ERROR_EXPECTED = _opensync.ERROR_EXPECTED
ERROR_NO_CONNECTION = _opensync.ERROR_NO_CONNECTION
ERROR_TEMPORARY = _opensync.ERROR_TEMPORARY
ERROR_LOCKED = _opensync.ERROR_LOCKED
ERROR_PLUGIN_NOT_FOUND = _opensync.ERROR_PLUGIN_NOT_FOUND
class Context(object):
    """Proxy of C Context struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, PyObject obj) -> Context
        __init__(self) -> Context
        """
        this = _opensync.new_Context(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Context
    __del__ = lambda self : None;
    def report_error(self, *args):
        """report_error(self, ErrorType type, char msg)"""
        return _opensync.Context_report_error(self, *args)

    def report_success(self):
        """report_success(self)"""
        return _opensync.Context_report_success(self)

    def report_osyncerror(self, *args):
        """report_osyncerror(self, Error error)"""
        return _opensync.Context_report_osyncerror(self, *args)

    def report_osyncwarning(self, *args):
        """report_osyncwarning(self, Error error)"""
        return _opensync.Context_report_osyncwarning(self, *args)

    def report_change(self, *args):
        """report_change(self, Change change)"""
        return _opensync.Context_report_change(self, *args)

    def set_callback_object(self, *args):
        """set_callback_object(self, PyObject handler)"""
        return _opensync.Context_set_callback_object(self, *args)

Context_swigregister = _opensync.Context_swigregister
Context_swigregister(Context)

class ContextCallbacks:
	"""A purely-Python class that should be subclassed by code that wishes to handle context callbacks."""
	def callback(self, err):
		"""If err is set, this call indicates that an error was reported. Otherwise success."""
		pass

	def changes(self, change):
		"""Called to report a change object."""
		pass

	def warning(self, err):
		"""Called to report a non-fatal error."""
		pass

CONV_DATA_UNKNOWN = _opensync.CONV_DATA_UNKNOWN
CONV_DATA_MISMATCH = _opensync.CONV_DATA_MISMATCH
CONV_DATA_SIMILAR = _opensync.CONV_DATA_SIMILAR
CONV_DATA_SAME = _opensync.CONV_DATA_SAME
class Data(object):
    """Proxy of C Data struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char buf, ObjFormat format) -> Data"""
        this = _opensync.new_Data(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Data
    __del__ = lambda self : None;
    def get_objformat(self):
        """get_objformat(self) -> ObjFormat"""
        return _opensync.Data_get_objformat(self)

    def set_objformat(self, *args):
        """set_objformat(self, ObjFormat objformat)"""
        return _opensync.Data_set_objformat(self, *args)

    def get_objtype(self):
        """get_objtype(self) -> char"""
        return _opensync.Data_get_objtype(self)

    def set_objtype(self, *args):
        """set_objtype(self, char objtype)"""
        return _opensync.Data_set_objtype(self, *args)

    def get_data(self):
        """get_data(self)"""
        return _opensync.Data_get_data(self)

    def set_data(self, *args):
        """set_data(self, char buffer, unsigned int size)"""
        return _opensync.Data_set_data(self, *args)

    def has_data(self):
        """has_data(self) -> bool"""
        return _opensync.Data_has_data(self)

    def clone(self):
        """clone(self) -> Data"""
        return _opensync.Data_clone(self)

    def get_printable(self):
        """get_printable(self) -> char"""
        return _opensync.Data_get_printable(self)

    def get_revision(self):
        """get_revision(self) -> time_t"""
        return _opensync.Data_get_revision(self)

    objformat = property(get_objformat, set_objformat)
    objtype = property(get_objtype, set_objtype)
    data = property(get_data, set_data)
    revision = property(get_revision)

Data_swigregister = _opensync.Data_swigregister
Data_swigregister(Data)

CHANGE_TYPE_UNKNOWN = _opensync.CHANGE_TYPE_UNKNOWN
CHANGE_TYPE_ADDED = _opensync.CHANGE_TYPE_ADDED
CHANGE_TYPE_UNMODIFIED = _opensync.CHANGE_TYPE_UNMODIFIED
CHANGE_TYPE_DELETED = _opensync.CHANGE_TYPE_DELETED
CHANGE_TYPE_MODIFIED = _opensync.CHANGE_TYPE_MODIFIED
class Change(object):
    """Proxy of C Change struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, PyObject obj) -> Change
        __init__(self) -> Change
        """
        this = _opensync.new_Change(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Change
    __del__ = lambda self : None;
    def set_hash(self, *args):
        """set_hash(self, char hash)"""
        return _opensync.Change_set_hash(self, *args)

    def get_hash(self):
        """get_hash(self) -> char"""
        return _opensync.Change_get_hash(self)

    def set_uid(self, *args):
        """set_uid(self, char uid)"""
        return _opensync.Change_set_uid(self, *args)

    def get_uid(self):
        """get_uid(self) -> char"""
        return _opensync.Change_get_uid(self)

    def set_changetype(self, *args):
        """set_changetype(self, ChangeType changetype)"""
        return _opensync.Change_set_changetype(self, *args)

    def get_changetype(self):
        """get_changetype(self) -> ChangeType"""
        return _opensync.Change_get_changetype(self)

    def set_data(self, *args):
        """set_data(self, Data data)"""
        return _opensync.Change_set_data(self, *args)

    def get_data(self):
        """get_data(self) -> Data"""
        return _opensync.Change_get_data(self)

    def compare(self, *args):
        """compare(self, Change change) -> ConvCmpResult"""
        return _opensync.Change_compare(self, *args)

    def get_objformat(self):
        """get_objformat(self) -> ObjFormat"""
        return _opensync.Change_get_objformat(self)

    def set_objtype(self, *args):
        """set_objtype(self, char objtype)"""
        return _opensync.Change_set_objtype(self, *args)

    def get_objtype(self):
        """get_objtype(self) -> char"""
        return _opensync.Change_get_objtype(self)

    hash = property(get_hash, set_hash)
    uid = property(get_uid, set_uid)
    changetype = property(get_changetype, set_changetype)
    data = property(get_data, set_data)
    objformat = property(get_objformat)
    objtype = property(get_objtype, set_objtype)

Change_swigregister = _opensync.Change_swigregister
Change_swigregister(Change)

ENGINE_COMMAND_CONNECT = _opensync.ENGINE_COMMAND_CONNECT
ENGINE_COMMAND_READ = _opensync.ENGINE_COMMAND_READ
ENGINE_COMMAND_WRITE = _opensync.ENGINE_COMMAND_WRITE
ENGINE_COMMAND_SYNC_DONE = _opensync.ENGINE_COMMAND_SYNC_DONE
ENGINE_COMMAND_DISCONNECT = _opensync.ENGINE_COMMAND_DISCONNECT
ENGINE_COMMAND_SOLVE = _opensync.ENGINE_COMMAND_SOLVE
ENGINE_COMMAND_DISCOVER = _opensync.ENGINE_COMMAND_DISCOVER
ENGINE_STATE_UNINITIALIZED = _opensync.ENGINE_STATE_UNINITIALIZED
ENGINE_STATE_INITIALIZED = _opensync.ENGINE_STATE_INITIALIZED
ENGINE_STATE_WAITING = _opensync.ENGINE_STATE_WAITING
ENGINE_STATE_CONNECTING = _opensync.ENGINE_STATE_CONNECTING
ENGINE_STATE_READING = _opensync.ENGINE_STATE_READING
ENGINE_STATE_WRITING = _opensync.ENGINE_STATE_WRITING
ENGINE_STATE_DISCONNECTING = _opensync.ENGINE_STATE_DISCONNECTING
ENGINE_EVENT_CONNECTED = _opensync.ENGINE_EVENT_CONNECTED
ENGINE_EVENT_ERROR = _opensync.ENGINE_EVENT_ERROR
ENGINE_EVENT_READ = _opensync.ENGINE_EVENT_READ
ENGINE_EVENT_WRITTEN = _opensync.ENGINE_EVENT_WRITTEN
ENGINE_EVENT_SYNC_DONE = _opensync.ENGINE_EVENT_SYNC_DONE
ENGINE_EVENT_DISCONNECTED = _opensync.ENGINE_EVENT_DISCONNECTED
ENGINE_EVENT_SUCCESSFUL = _opensync.ENGINE_EVENT_SUCCESSFUL
ENGINE_EVENT_END_CONFLICTS = _opensync.ENGINE_EVENT_END_CONFLICTS
ENGINE_EVENT_PREV_UNCLEAN = _opensync.ENGINE_EVENT_PREV_UNCLEAN
ENGINE_MEMBER_EVENT_CONNECTED = _opensync.ENGINE_MEMBER_EVENT_CONNECTED
ENGINE_MEMBER_EVENT_ERROR = _opensync.ENGINE_MEMBER_EVENT_ERROR
ENGINE_MEMBER_EVENT_READ = _opensync.ENGINE_MEMBER_EVENT_READ
ENGINE_MEMBER_EVENT_WRITTEN = _opensync.ENGINE_MEMBER_EVENT_WRITTEN
ENGINE_MEMBER_EVENT_SYNC_DONE = _opensync.ENGINE_MEMBER_EVENT_SYNC_DONE
ENGINE_MEMBER_EVENT_DISCONNECTED = _opensync.ENGINE_MEMBER_EVENT_DISCONNECTED
ENGINE_MEMBER_EVENT_DISCOVERED = _opensync.ENGINE_MEMBER_EVENT_DISCOVERED
ENGINE_CHANGE_EVENT_READ = _opensync.ENGINE_CHANGE_EVENT_READ
ENGINE_CHANGE_EVENT_WRITTEN = _opensync.ENGINE_CHANGE_EVENT_WRITTEN
ENGINE_CHANGE_EVENT_ERROR = _opensync.ENGINE_CHANGE_EVENT_ERROR
ENGINE_MAPPING_EVENT_SOLVED = _opensync.ENGINE_MAPPING_EVENT_SOLVED
ENGINE_MAPPING_EVENT_ERROR = _opensync.ENGINE_MAPPING_EVENT_ERROR
class Engine(object):
    """Proxy of C Engine struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Group group) -> Engine"""
        this = _opensync.new_Engine(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Engine
    __del__ = lambda self : None;
    def initialize(self):
        """initialize(self)"""
        return _opensync.Engine_initialize(self)

    def finalize(self):
        """finalize(self)"""
        return _opensync.Engine_finalize(self)

    def synchronize(self):
        """synchronize(self)"""
        return _opensync.Engine_synchronize(self)

    def synchronize_and_block(self):
        """synchronize_and_block(self)"""
        return _opensync.Engine_synchronize_and_block(self)

    def wait_sync_end(self):
        """wait_sync_end(self)"""
        return _opensync.Engine_wait_sync_end(self)

    def discover(self, *args):
        """discover(self, Member member)"""
        return _opensync.Engine_discover(self, *args)

    def discover_and_block(self, *args):
        """discover_and_block(self, Member member)"""
        return _opensync.Engine_discover_and_block(self, *args)

    def set_enginestatus_callback(self, *args):
        """set_enginestatus_callback(self, PyObject pyfunc)"""
        return _opensync.Engine_set_enginestatus_callback(self, *args)

    # group = property(get_group)
    # archive = property(get_archive)

Engine_swigregister = _opensync.Engine_swigregister
Engine_swigregister(Engine)

CONVERTER_CONV = _opensync.CONVERTER_CONV
CONVERTER_ENCAP = _opensync.CONVERTER_ENCAP
CONVERTER_DECAP = _opensync.CONVERTER_DECAP
CONVERTER_DETECTOR = _opensync.CONVERTER_DETECTOR
class FormatConverter(object):
    """Proxy of C FormatConverter struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> FormatConverter"""
        this = _opensync.new_FormatConverter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_FormatConverter
    __del__ = lambda self : None;
    def get_sourceformat(self):
        """get_sourceformat(self) -> ObjFormat"""
        return _opensync.FormatConverter_get_sourceformat(self)

    def get_targetformat(self):
        """get_targetformat(self) -> ObjFormat"""
        return _opensync.FormatConverter_get_targetformat(self)

    def get_type(self):
        """get_type(self) -> OSyncConverterType"""
        return _opensync.FormatConverter_get_type(self)

    def detect(self, *args):
        """detect(self, Data data) -> ObjFormat"""
        return _opensync.FormatConverter_detect(self, *args)

    def invoke(self, *args):
        """invoke(self, Data data, char config)"""
        return _opensync.FormatConverter_invoke(self, *args)

    def matches(self, *args):
        """matches(self, Data data) -> bool"""
        return _opensync.FormatConverter_matches(self, *args)

    sourceformat = property(get_sourceformat)
    targetformat = property(get_targetformat)
    type = property(get_type)

FormatConverter_swigregister = _opensync.FormatConverter_swigregister
FormatConverter_swigregister(FormatConverter)

class FormatConverterPath(object):
    """Proxy of C FormatConverterPath struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> FormatConverterPath"""
        this = _opensync.new_FormatConverterPath()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_FormatConverterPath
    __del__ = lambda self : None;
    def add_edge(self, *args):
        """add_edge(self, FormatConverter edge)"""
        return _opensync.FormatConverterPath_add_edge(self, *args)

    def get_config(self):
        """get_config(self) -> char"""
        return _opensync.FormatConverterPath_get_config(self)

    def set_config(self, *args):
        """set_config(self, char config)"""
        return _opensync.FormatConverterPath_set_config(self, *args)

    config = property(get_config, set_config)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)

FormatConverterPath_swigregister = _opensync.FormatConverterPath_swigregister
FormatConverterPath_swigregister(FormatConverterPath)

class FormatEnv(object):
    """Proxy of C FormatEnv struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> FormatEnv"""
        this = _opensync.new_FormatEnv()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_FormatEnv
    __del__ = lambda self : None;
    def load_plugins(self, path = None):
        """load_plugins(self, char path = None)"""
        return _opensync.FormatEnv_load_plugins(self, path)

    def register_objformat(self, *args):
        """register_objformat(self, ObjFormat format)"""
        return _opensync.FormatEnv_register_objformat(self, *args)

    def find_objformat(self, *args):
        """find_objformat(self, char name) -> ObjFormat"""
        return _opensync.FormatEnv_find_objformat(self, *args)

    def register_converter(self, *args):
        """register_converter(self, FormatConverter converter)"""
        return _opensync.FormatEnv_register_converter(self, *args)

    def find_converter(self, *args):
        """find_converter(self, ObjFormat sourceformat, ObjFormat targetformat) -> FormatConverter"""
        return _opensync.FormatEnv_find_converter(self, *args)

    def detect_objformat(self, *args):
        """detect_objformat(self, Data data) -> ObjFormat"""
        return _opensync.FormatEnv_detect_objformat(self, *args)

    def detect_objformat_full(self, *args):
        """detect_objformat_full(self, Data input) -> ObjFormat"""
        return _opensync.FormatEnv_detect_objformat_full(self, *args)

    def convert(self, *args):
        """convert(self, FormatConverterPath path, Data data)"""
        return _opensync.FormatEnv_convert(self, *args)

    def find_path(self, *args):
        """find_path(self, ObjFormat sourceformat, ObjFormat targetformat) -> FormatConverterPath"""
        return _opensync.FormatEnv_find_path(self, *args)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)
                   
    	# self.filters = _ListWrapper(self.num_filters, self.nth_filter)
                   

FormatEnv_swigregister = _opensync.FormatEnv_swigregister
FormatEnv_swigregister(FormatEnv)

class ObjFormat(object):
    """Proxy of C ObjFormat struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char name, char objtype_name) -> ObjFormat"""
        this = _opensync.new_ObjFormat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_ObjFormat
    __del__ = lambda self : None;
    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.ObjFormat_get_name(self)

    def get_objtype(self):
        """get_objtype(self) -> char"""
        return _opensync.ObjFormat_get_objtype(self)

    name = property(get_name)
    objtype = property(get_objtype)

ObjFormat_swigregister = _opensync.ObjFormat_swigregister
ObjFormat_swigregister(ObjFormat)

class ObjFormatSink(object):
    """Proxy of C ObjFormatSink struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char name) -> ObjFormatSink"""
        this = _opensync.new_ObjFormatSink(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_ObjFormatSink
    __del__ = lambda self : None;
    def get_objformat(self):
        """get_objformat(self) -> char"""
        return _opensync.ObjFormatSink_get_objformat(self)

    def get_config(self):
        """get_config(self) -> char"""
        return _opensync.ObjFormatSink_get_config(self)

    def set_config(self, *args):
        """set_config(self, char config)"""
        return _opensync.ObjFormatSink_set_config(self, *args)

    config = property(get_config)
    objformat = property(get_objformat)

ObjFormatSink_swigregister = _opensync.ObjFormatSink_swigregister
ObjFormatSink_swigregister(ObjFormatSink)

class GroupEnv(object):
    """Proxy of C GroupEnv struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> GroupEnv"""
        this = _opensync.new_GroupEnv()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_GroupEnv
    __del__ = lambda self : None;
    def load_groups(self, path = None):
        """load_groups(self, char path = None)"""
        return _opensync.GroupEnv_load_groups(self, path)

    def find_group(self, *args):
        """find_group(self, char name) -> Group"""
        return _opensync.GroupEnv_find_group(self, *args)

    def add_group(self, *args):
        """add_group(self, Group group)"""
        return _opensync.GroupEnv_add_group(self, *args)

    def remove_group(self, *args):
        """remove_group(self, Group group)"""
        return _opensync.GroupEnv_remove_group(self, *args)

    def num_groups(self):
        """num_groups(self) -> int"""
        return _opensync.GroupEnv_num_groups(self)

    def nth_group(self, *args):
        """nth_group(self, int nth) -> Group"""
        return _opensync.GroupEnv_nth_group(self, *args)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)
    	self.groups = _ListWrapper(self.num_groups, self.nth_group)

GroupEnv_swigregister = _opensync.GroupEnv_swigregister
GroupEnv_swigregister(GroupEnv)

LOCK_OK = _opensync.LOCK_OK
LOCKED = _opensync.LOCKED
LOCK_STALE = _opensync.LOCK_STALE
CONFLICT_RESOLUTION_UNKNOWN = _opensync.CONFLICT_RESOLUTION_UNKNOWN
CONFLICT_RESOLUTION_DUPLICATE = _opensync.CONFLICT_RESOLUTION_DUPLICATE
CONFLICT_RESOLUTION_IGNORE = _opensync.CONFLICT_RESOLUTION_IGNORE
CONFLICT_RESOLUTION_NEWER = _opensync.CONFLICT_RESOLUTION_NEWER
CONFLICT_RESOLUTION_SELECT = _opensync.CONFLICT_RESOLUTION_SELECT
class Group(object):
    """Proxy of C Group struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Group"""
        this = _opensync.new_Group()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Group
    __del__ = lambda self : None;
    def lock(self):
        """lock(self) -> LockState"""
        return _opensync.Group_lock(self)

    def unlock(self):
        """unlock(self)"""
        return _opensync.Group_unlock(self)

    def set_name(self, *args):
        """set_name(self, char name)"""
        return _opensync.Group_set_name(self, *args)

    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.Group_get_name(self)

    def save(self):
        """save(self)"""
        return _opensync.Group_save(self)

    def delete(self):
        """delete(self)"""
        return _opensync.Group_delete(self)

    def reset(self):
        """reset(self)"""
        return _opensync.Group_reset(self)

    def load(self, *args):
        """load(self, char path)"""
        return _opensync.Group_load(self, *args)

    def add_member(self, *args):
        """add_member(self, Member member)"""
        return _opensync.Group_add_member(self, *args)

    def remove_member(self, *args):
        """remove_member(self, Member member)"""
        return _opensync.Group_remove_member(self, *args)

    def find_member(self, *args):
        """find_member(self, int id) -> Member"""
        return _opensync.Group_find_member(self, *args)

    def num_members(self):
        """num_members(self) -> int"""
        return _opensync.Group_num_members(self)

    def nth_member(self, *args):
        """nth_member(self, int nth) -> Member"""
        return _opensync.Group_nth_member(self, *args)

    def get_configdir(self):
        """get_configdir(self) -> char"""
        return _opensync.Group_get_configdir(self)

    def set_configdir(self, *args):
        """set_configdir(self, char directory)"""
        return _opensync.Group_set_configdir(self, *args)

    def num_objtypes(self):
        """num_objtypes(self) -> int"""
        return _opensync.Group_num_objtypes(self)

    def nth_objtype(self, *args):
        """nth_objtype(self, int nth) -> char"""
        return _opensync.Group_nth_objtype(self, *args)

    def set_objtype_enabled(self, *args):
        """set_objtype_enabled(self, char objtype, bool enabled)"""
        return _opensync.Group_set_objtype_enabled(self, *args)

    def objtype_enabled(self, *args):
        """objtype_enabled(self, char objtype) -> int"""
        return _opensync.Group_objtype_enabled(self, *args)

    def get_last_synchronization(self):
        """get_last_synchronization(self) -> time_t"""
        return _opensync.Group_get_last_synchronization(self)

    def set_conflict_resolution(self, *args):
        """set_conflict_resolution(self, ConflictResolution res, int num)"""
        return _opensync.Group_set_conflict_resolution(self, *args)

    def get_conflict_resolution(self, *args):
        """get_conflict_resolution(self, long long winner)"""
        return _opensync.Group_get_conflict_resolution(self, *args)

    def get_merger_enabled(self):
        """get_merger_enabled(self) -> bool"""
        return _opensync.Group_get_merger_enabled(self)

    def set_merger_enabled(self, *args):
        """set_merger_enabled(self, bool enable_merger)"""
        return _opensync.Group_set_merger_enabled(self, *args)

    def get_converter_enabled(self):
        """get_converter_enabled(self) -> bool"""
        return _opensync.Group_get_converter_enabled(self)

    def set_converter_enabled(self, *args):
        """set_converter_enabled(self, bool enable_converter)"""
        return _opensync.Group_set_converter_enabled(self, *args)

    name = property(get_name, set_name)
    configdir = property(get_configdir, set_configdir)
    last_synchronization = property(get_last_synchronization)
    merger_enabled = property(get_merger_enabled, set_merger_enabled)
    converter_enabled = property(get_converter_enabled, set_converter_enabled)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)
                   
    	self.members = _ListWrapper(self.num_members, self.nth_member)
    	self.objtypes = _ListWrapper(self.num_objtypes, self.nth_objtype)
    	# self.filters = _ListWrapper(self.num_filters, self.nth_filter)

Group_swigregister = _opensync.Group_swigregister
Group_swigregister(Group)

class Member(object):
    """Proxy of C Member struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Member"""
        this = _opensync.new_Member()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Member
    __del__ = lambda self : None;
    def get_pluginname(self):
        """get_pluginname(self) -> char"""
        return _opensync.Member_get_pluginname(self)

    def set_pluginname(self, *args):
        """set_pluginname(self, char pluginname)"""
        return _opensync.Member_set_pluginname(self, *args)

    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.Member_get_name(self)

    def set_name(self, *args):
        """set_name(self, char name)"""
        return _opensync.Member_set_name(self, *args)

    def get_configdir(self):
        """get_configdir(self) -> char"""
        return _opensync.Member_get_configdir(self)

    def set_configdir(self, *args):
        """set_configdir(self, char configdir)"""
        return _opensync.Member_set_configdir(self, *args)

    def get_config_or_default(self):
        """get_config_or_default(self) -> PluginConfig"""
        return _opensync.Member_get_config_or_default(self)

    def has_config(self):
        """has_config(self) -> bool"""
        return _opensync.Member_has_config(self)

    def get_config(self):
        """get_config(self) -> PluginConfig"""
        return _opensync.Member_get_config(self)

    def set_config(self, *args):
        """set_config(self, PluginConfig data)"""
        return _opensync.Member_set_config(self, *args)

    def load(self, *args):
        """load(self, char path)"""
        return _opensync.Member_load(self, *args)

    def save(self):
        """save(self)"""
        return _opensync.Member_save(self)

    def delete(self):
        """delete(self)"""
        return _opensync.Member_delete(self)

    def get_id(self):
        """get_id(self) -> long long"""
        return _opensync.Member_get_id(self)

    def add_objformat(self, *args):
        """add_objformat(self, char objtype, char format)"""
        return _opensync.Member_add_objformat(self, *args)

    def get_objformats(self, *args):
        """get_objformats(self, char objtype) -> PyObject"""
        return _opensync.Member_get_objformats(self, *args)

    def add_objtype_sink(self, *args):
        """add_objtype_sink(self, ObjTypeSink sink)"""
        return _opensync.Member_add_objtype_sink(self, *args)

    def objtype_enabled(self, *args):
        """objtype_enabled(self, char objtype) -> bool"""
        return _opensync.Member_objtype_enabled(self, *args)

    def set_objtype_enabled(self, *args):
        """set_objtype_enabled(self, char objtype, bool enabled)"""
        return _opensync.Member_set_objtype_enabled(self, *args)

    def get_capabilities(self):
        """get_capabilities(self) -> Capabilities"""
        return _opensync.Member_get_capabilities(self)

    def set_capabilities(self, *args):
        """set_capabilities(self, Capabilities capabilities)"""
        return _opensync.Member_set_capabilities(self, *args)

    def flush_objtypes(self):
        """flush_objtypes(self)"""
        return _opensync.Member_flush_objtypes(self)

    pluginname = property(get_pluginname, set_pluginname)
    name = property(get_name, set_name)
    configdir = property(get_configdir, set_configdir)
    config = property(get_config, set_config)
    id = property(get_id)
    capabilities = property(get_capabilities, set_capabilities)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)

Member_swigregister = _opensync.Member_swigregister
Member_swigregister(Member)


def sink_state_equal(*args):
  """sink_state_equal(OSyncSinkStateDB state_db, char key, char value) -> bool"""
  return _opensync.sink_state_equal(*args)

def sink_state_set(*args):
  """sink_state_set(OSyncSinkStateDB state_db, char key, char value) -> bool"""
  return _opensync.sink_state_set(*args)

def sink_state_get(*args):
  """sink_state_get(OSyncSinkStateDB state_db, char key) -> char"""
  return _opensync.sink_state_get(*args)

def hashtable_slowsync(*args):
  """hashtable_slowsync(OSyncHashTable hashtable) -> bool"""
  return _opensync.hashtable_slowsync(*args)

def hashtable_update_change(*args):
  """hashtable_update_change(OSyncHashTable hashtable, Change change)"""
  return _opensync.hashtable_update_change(*args)

def hashtable_get_deleted(*args):
  """hashtable_get_deleted(OSyncHashTable hashtable) -> PyObject"""
  return _opensync.hashtable_get_deleted(*args)

def hashtable_get_changetype(*args):
  """hashtable_get_changetype(OSyncHashTable hashtable, Change change) -> ChangeType"""
  return _opensync.hashtable_get_changetype(*args)
class Capability(object):
    """Proxy of C Capability struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, OSyncCapabilitiesObjType capobjtype) -> Capability"""
        this = _opensync.new_Capability(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Capability
    __del__ = lambda self : None;
    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.Capability_get_name(self)

    name = property(get_name)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)

Capability_swigregister = _opensync.Capability_swigregister
Capability_swigregister(Capability)

class Capabilities(object):
    """Proxy of C Capabilities struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char capsformat) -> Capabilities"""
        this = _opensync.new_Capabilities(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Capabilities
    __del__ = lambda self : None;
Capabilities_swigregister = _opensync.Capabilities_swigregister
Capabilities_swigregister(Capabilities)

class XMLFormat(object):
    """Proxy of C XMLFormat struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char objtype) -> XMLFormat"""
        this = _opensync.new_XMLFormat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_XMLFormat
    __del__ = lambda self : None;
    def get_first_field(self):
        """get_first_field(self) -> XMLField"""
        return _opensync.XMLFormat_get_first_field(self)

    def search_field(self, *args):
        """search_field(self, char name) -> PyObject"""
        return _opensync.XMLFormat_search_field(self, *args)

    def assemble(self):
        """assemble(self) -> PyObject"""
        return _opensync.XMLFormat_assemble(self)

    def sort(self):
        """sort(self)"""
        return _opensync.XMLFormat_sort(self)

    def get_objtype(self):
        """get_objtype(self) -> char"""
        return _opensync.XMLFormat_get_objtype(self)

    objtype = property(get_objtype)

XMLFormat_swigregister = _opensync.XMLFormat_swigregister
XMLFormat_swigregister(XMLFormat)


def xmlformat_parse(*args):
  """xmlformat_parse(char buffer) -> XMLFormat"""
  return _opensync.xmlformat_parse(*args)
class XMLField(object):
    """Proxy of C XMLField struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, XMLFormat xmlformat, char name) -> XMLField"""
        this = _opensync.new_XMLField(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_XMLField
    __del__ = lambda self : None;
    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.XMLField_get_name(self)

    def get_next(self):
        """get_next(self) -> XMLField"""
        return _opensync.XMLField_get_next(self)

    def get_attr(self, *args):
        """get_attr(self, char attr) -> char"""
        return _opensync.XMLField_get_attr(self, *args)

    def set_attr(self, *args):
        """set_attr(self, char attr, char value)"""
        return _opensync.XMLField_set_attr(self, *args)

    def get_attr_count(self):
        """get_attr_count(self) -> int"""
        return _opensync.XMLField_get_attr_count(self)

    def get_nth_attr_name(self, *args):
        """get_nth_attr_name(self, int nth) -> char"""
        return _opensync.XMLField_get_nth_attr_name(self, *args)

    def get_nth_attr_value(self, *args):
        """get_nth_attr_value(self, int nth) -> char"""
        return _opensync.XMLField_get_nth_attr_value(self, *args)

    def get_key_value(self, *args):
        """get_key_value(self, char key) -> char"""
        return _opensync.XMLField_get_key_value(self, *args)

    def set_key_value(self, *args):
        """set_key_value(self, char key, char value)"""
        return _opensync.XMLField_set_key_value(self, *args)

    def add_key_value(self, *args):
        """add_key_value(self, char key, char value)"""
        return _opensync.XMLField_add_key_value(self, *args)

    def get_key_count(self):
        """get_key_count(self) -> int"""
        return _opensync.XMLField_get_key_count(self)

    def get_nth_key_name(self, *args):
        """get_nth_key_name(self, int nth) -> char"""
        return _opensync.XMLField_get_nth_key_name(self, *args)

    def get_nth_key_value(self, *args):
        """get_nth_key_value(self, int nth) -> char"""
        return _opensync.XMLField_get_nth_key_value(self, *args)

    def set_nth_key_value(self, *args):
        """set_nth_key_value(self, int nth, char value)"""
        return _opensync.XMLField_set_nth_key_value(self, *args)

    name = property(get_name)
    next = property(get_next)

    # map attributes and keys to two properties of the XMLField object
    class Attrs:
    	def __init__(self, xmlfield):
    		self.xmlfield = xmlfield
    	def __len__(self):
    		return self.xmlfield.get_attr_count()
    	def __getitem__(self, key):
    		return self.xmlfield.get_attr(key)
    	def __setitem__(self, key, value):
    		self.xmlfield.set_attr(key, value)
    	def __iter__(self):
    		class Iter:
    			def __init__(self, xmlfield):
    				self.xmlfield = xmlfield
    				self.pos = 0
    				self.maxpos = self.xmlfield.get_attr_count()
    			def __iter__(self):
    				return self
    			def next(self):
    				if self.pos > self.maxpos:
    					raise StopIteration
    				name = self.xmlfield.get_nth_attr_name(self.pos)
    				value = self.xmlfield.get_nth_attr_value(self.pos)
    				self.pos += 1
    				return (name, value)
    		return Iter(self.xmlfield)

    class Keys:
    	def __init__(self, xmlfield):
    		self.xmlfield = xmlfield
    	def __len__(self):
    		return self.xmlfield.get_key_count()
    	def __getitem__(self, key):
    		return self.xmlfield.get_key_value(key)
    	def __setitem__(self, key, value):
    		self.xmlfield.set_key_value(key, value)
    	def __iter__(self):
    		class Iter:
    			def __init__(self, xmlfield):
    				self.xmlfield = xmlfield
    				self.pos = 0
    				self.maxpos = self.xmlfield.get_key_count()
    			def __iter__(self):
    				return self
    			def next(self):
    				if self.pos > self.maxpos:
    					raise StopIteration
    				name = self.xmlfield.get_nth_key_name(self.pos)
    				value = self.xmlfield.get_nth_key_value(self.pos)
    				self.pos += 1
    				return (name, value)
    		return Iter(self.xmlfield)

    attrs = property(Attrs)
    keys = property(Keys)

XMLField_swigregister = _opensync.XMLField_swigregister
XMLField_swigregister(XMLField)

PLUGIN_NO_CONFIGURATION = _opensync.PLUGIN_NO_CONFIGURATION
PLUGIN_OPTIONAL_CONFIGURATION = _opensync.PLUGIN_OPTIONAL_CONFIGURATION
PLUGIN_NEEDS_CONFIGURATION = _opensync.PLUGIN_NEEDS_CONFIGURATION
START_TYPE_UNKNOWN = _opensync.START_TYPE_UNKNOWN
START_TYPE_PROCESS = _opensync.START_TYPE_PROCESS
START_TYPE_THREAD = _opensync.START_TYPE_THREAD
START_TYPE_EXTERNAL = _opensync.START_TYPE_EXTERNAL
class Plugin(object):
    """Proxy of C Plugin struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, PyObject obj) -> Plugin
        __init__(self) -> Plugin
        """
        this = _opensync.new_Plugin(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Plugin
    __del__ = lambda self : None;
    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.Plugin_get_name(self)

    def set_name(self, *args):
        """set_name(self, char name)"""
        return _opensync.Plugin_set_name(self, *args)

    def get_longname(self):
        """get_longname(self) -> char"""
        return _opensync.Plugin_get_longname(self)

    def set_longname(self, *args):
        """set_longname(self, char longname)"""
        return _opensync.Plugin_set_longname(self, *args)

    def get_description(self):
        """get_description(self) -> char"""
        return _opensync.Plugin_get_description(self)

    def set_description(self, *args):
        """set_description(self, char description)"""
        return _opensync.Plugin_set_description(self, *args)

    def get_config_type(self):
        """get_config_type(self) -> ConfigurationType"""
        return _opensync.Plugin_get_config_type(self)

    def set_config_type(self, *args):
        """set_config_type(self, ConfigurationType config_type)"""
        return _opensync.Plugin_set_config_type(self, *args)

    def initialize(self, *args):
        """initialize(self, PluginInfo info, void plugin_data) -> osync_bool"""
        return _opensync.Plugin_initialize(self, *args)

    def finalize(self, *args):
        """finalize(self, void data)"""
        return _opensync.Plugin_finalize(self, *args)

    def discover(self, *args):
        """discover(self, void data, PluginInfo info)"""
        return _opensync.Plugin_discover(self, *args)

    name = property(get_name, set_name)
    longname = property(get_longname, set_longname)
    description = property(get_description, set_description)
    config_type = property(get_config_type, set_config_type)

Plugin_swigregister = _opensync.Plugin_swigregister
Plugin_swigregister(Plugin)

class PluginEnv(object):
    """Proxy of C PluginEnv struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> PluginEnv"""
        this = _opensync.new_PluginEnv()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_PluginEnv
    __del__ = lambda self : None;
    def load(self, path = None):
        """load(self, char path = None)"""
        return _opensync.PluginEnv_load(self, path)

    def register_plugin(self, *args):
        """register_plugin(self, Plugin plugin)"""
        return _opensync.PluginEnv_register_plugin(self, *args)

    def find_plugin(self, *args):
        """find_plugin(self, char name) -> Plugin"""
        return _opensync.PluginEnv_find_plugin(self, *args)

    def num_plugins(self):
        """num_plugins(self) -> int"""
        return _opensync.PluginEnv_num_plugins(self)

    def nth_plugin(self, *args):
        """nth_plugin(self, int nth) -> Plugin"""
        return _opensync.PluginEnv_nth_plugin(self, *args)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)
    	self.plugins = _ListWrapper(self.num_plugins, self.nth_plugin)

PluginEnv_swigregister = _opensync.PluginEnv_swigregister
PluginEnv_swigregister(PluginEnv)

class PluginInfo(object):
    """Proxy of C PluginInfo struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, PyObject obj) -> PluginInfo
        __init__(self) -> PluginInfo
        """
        this = _opensync.new_PluginInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_PluginInfo
    __del__ = lambda self : None;
    def set_loop(self, *args):
        """set_loop(self, void loop)"""
        return _opensync.PluginInfo_set_loop(self, *args)

    def get_loop(self):
        """get_loop(self) -> void"""
        return _opensync.PluginInfo_get_loop(self)

    def set_config(self, *args):
        """set_config(self, PluginConfig config)"""
        return _opensync.PluginInfo_set_config(self, *args)

    def get_config(self):
        """get_config(self) -> PluginConfig"""
        return _opensync.PluginInfo_get_config(self)

    def set_configdir(self, *args):
        """set_configdir(self, char configdir)"""
        return _opensync.PluginInfo_set_configdir(self, *args)

    def find_objtype(self, *args):
        """find_objtype(self, char name) -> ObjTypeSink"""
        return _opensync.PluginInfo_find_objtype(self, *args)

    def add_objtype(self, *args):
        """add_objtype(self, ObjTypeSink sink)"""
        return _opensync.PluginInfo_add_objtype(self, *args)

    def num_objtype_sinks(self):
        """num_objtype_sinks(self) -> unsigned int"""
        return _opensync.PluginInfo_num_objtype_sinks(self)

    def nth_objtype(self, *args):
        """nth_objtype(self, int nth) -> ObjTypeSink"""
        return _opensync.PluginInfo_nth_objtype(self, *args)

    def get_main_sink(self):
        """get_main_sink(self) -> ObjTypeSink"""
        return _opensync.PluginInfo_get_main_sink(self)

    def set_main_sink(self, *args):
        """set_main_sink(self, ObjTypeSink sink)"""
        return _opensync.PluginInfo_set_main_sink(self, *args)

    def get_format_env(self):
        """get_format_env(self) -> FormatEnv"""
        return _opensync.PluginInfo_get_format_env(self)

    def set_format_env(self, *args):
        """set_format_env(self, FormatEnv env)"""
        return _opensync.PluginInfo_set_format_env(self, *args)

    def set_sink(self, *args):
        """set_sink(self, ObjTypeSink sink)"""
        return _opensync.PluginInfo_set_sink(self, *args)

    def set_groupname(self, *args):
        """set_groupname(self, char groupname)"""
        return _opensync.PluginInfo_set_groupname(self, *args)

    def get_groupname(self):
        """get_groupname(self) -> char"""
        return _opensync.PluginInfo_get_groupname(self)

    def set_version(self, *args):
        """set_version(self, Version version)"""
        return _opensync.PluginInfo_set_version(self, *args)

    def get_version(self):
        """get_version(self) -> Version"""
        return _opensync.PluginInfo_get_version(self)

    def set_capabilities(self, *args):
        """set_capabilities(self, Capabilities capabilities)"""
        return _opensync.PluginInfo_set_capabilities(self, *args)

    def get_capabilities(self):
        """get_capabilities(self) -> Capabilities"""
        return _opensync.PluginInfo_get_capabilities(self)

    loop = property(get_loop, set_loop)
    config = property(get_config, set_config)
    main_sink = property(get_main_sink, set_main_sink)
    format_env = property(get_format_env, set_format_env)
    # sink = property(get_sink, set_sink)
    groupname = property(get_groupname, set_groupname)
    version = property(get_version, set_version)
    capabilities = property(get_capabilities, set_capabilities)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)
    	self.objtypes = _ListWrapper(self.num_objtype_sinks, self.nth_objtype)

PluginInfo_swigregister = _opensync.PluginInfo_swigregister
PluginInfo_swigregister(PluginInfo)

class PluginConfig(object):
    """Proxy of C PluginConfig struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, PyObject obj) -> PluginConfig
        __init__(self) -> PluginConfig
        """
        this = _opensync.new_PluginConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_PluginConfig
    __del__ = lambda self : None;
PluginConfig_swigregister = _opensync.PluginConfig_swigregister
PluginConfig_swigregister(PluginConfig)

class ObjTypeSink(object):
    """Proxy of C ObjTypeSink struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char objtype, PyObject callback_obj = None) -> ObjTypeSink"""
        this = _opensync.new_ObjTypeSink(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_ObjTypeSink
    __del__ = lambda self : None;
    def get_name(self):
        """get_name(self) -> char"""
        return _opensync.ObjTypeSink_get_name(self)

    def set_name(self, *args):
        """set_name(self, char name)"""
        return _opensync.ObjTypeSink_set_name(self, *args)

    def find_objformat(self, *args):
        """find_objformat(self, ObjFormat objformat) -> ObjFormatSink"""
        return _opensync.ObjTypeSink_find_objformat(self, *args)

    def add_objformat(self, *args):
        """add_objformat(self, ObjFormatSink format_sink)"""
        return _opensync.ObjTypeSink_add_objformat(self, *args)

    def remove_objformat(self, *args):
        """remove_objformat(self, ObjFormatSink format_sink)"""
        return _opensync.ObjTypeSink_remove_objformat(self, *args)

    def get_state_db(self):
        """get_state_db(self) -> OSyncSinkStateDB"""
        return _opensync.ObjTypeSink_get_state_db(self)

    def get_hashtable(self):
        """get_hashtable(self) -> OSyncHashTable"""
        return _opensync.ObjTypeSink_get_hashtable(self)

    def is_enabled(self):
        """is_enabled(self) -> bool"""
        return _opensync.ObjTypeSink_is_enabled(self)

    def set_enabled(self, *args):
        """set_enabled(self, bool enabled)"""
        return _opensync.ObjTypeSink_set_enabled(self, *args)

    def is_available(self):
        """is_available(self) -> bool"""
        return _opensync.ObjTypeSink_is_available(self)

    def set_available(self, *args):
        """set_available(self, bool available)"""
        return _opensync.ObjTypeSink_set_available(self, *args)

    def get_write(self):
        """get_write(self) -> bool"""
        return _opensync.ObjTypeSink_get_write(self)

    def set_write(self, *args):
        """set_write(self, bool write)"""
        return _opensync.ObjTypeSink_set_write(self, *args)

    def get_read(self):
        """get_read(self) -> bool"""
        return _opensync.ObjTypeSink_get_read(self)

    def set_read(self, *args):
        """set_read(self, bool read)"""
        return _opensync.ObjTypeSink_set_read(self, *args)

    def num_objformatsinks(self):
        """num_objformatsinks(self) -> unsigned int"""
        return _opensync.ObjTypeSink_num_objformatsinks(self)

    def nth_objformatsink(self, *args):
        """nth_objformatsink(self, int nth) -> ObjFormatSink"""
        return _opensync.ObjTypeSink_nth_objformatsink(self, *args)

    name = property(get_name, set_name)
    enabled = property(is_enabled, set_enabled)
    available = property(is_available, set_available)
    write = property(get_write, set_write)
    read = property(get_read, set_read)
    #slowsync = property(get_slowsync, set_slowsync)
    #callback_obj = property(get_callback_obj)

    # extend the SWIG-generated constructor, so that we can setup our list-wrapper classes
    __oldinit = __init__
    def __init__(self, *args):
    	self.__oldinit(*args)
    	self.objformats = _ListWrapper(self.num_objformatsinks, self.nth_objformatsink)

ObjTypeSink_swigregister = _opensync.ObjTypeSink_swigregister
ObjTypeSink_swigregister(ObjTypeSink)

class ObjTypeSinkCallbacks:
	"""A purely-Python class that should be subclassed by plugins implementing their own sinks."""
	def __init__(self, objtype):
		# construct ObjTypeSink object and pass it our reference
		self.sink = ObjTypeSink(objtype, self)

	def connect(self, info, ctx):
		pass

	def get_changes(self, info, ctx):
		pass

	def commit(self, info, ctx, chg):
		pass

	def committed_all(self, info, ctx):
		pass

	def read(self, info, ctx, chg):
		pass

	def write(self, info, ctx, chg):
		pass

	def disconnect(self, info, ctx):
		pass

	def sync_done(self, info, ctx):
		pass

TRACE_ENTRY = _opensync.TRACE_ENTRY
TRACE_EXIT = _opensync.TRACE_EXIT
TRACE_INTERNAL = _opensync.TRACE_INTERNAL
TRACE_SENSITIVE = _opensync.TRACE_SENSITIVE
TRACE_EXIT_ERROR = _opensync.TRACE_EXIT_ERROR
TRACE_ERROR = _opensync.TRACE_ERROR

def trace_reset_indent():
  """trace_reset_indent()"""
  return _opensync.trace_reset_indent()

def trace(*args):
  """trace(TraceType type, char message)"""
  return _opensync.trace(*args)

def trace_disable():
  """trace_disable()"""
  return _opensync.trace_disable()

def trace_enable():
  """trace_enable()"""
  return _opensync.trace_enable()

def get_version():
  """get_version() -> char"""
  return _opensync.get_version()
# this won't change, so just call it once at module load time
version = get_version()

class Version(object):
    """Proxy of C Version struct"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Version"""
        this = _opensync.new_Version()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _opensync.delete_Version
    __del__ = lambda self : None;
    def set_priority(self, *args):
        """set_priority(self, char priority)"""
        return _opensync.Version_set_priority(self, *args)

    def set_vendor(self, *args):
        """set_vendor(self, char vendor)"""
        return _opensync.Version_set_vendor(self, *args)

    def set_plugin(self, *args):
        """set_plugin(self, char plugin)"""
        return _opensync.Version_set_plugin(self, *args)

    def set_modelversion(self, *args):
        """set_modelversion(self, char modelversion)"""
        return _opensync.Version_set_modelversion(self, *args)

    def set_firmwareversion(self, *args):
        """set_firmwareversion(self, char firmwareversion)"""
        return _opensync.Version_set_firmwareversion(self, *args)

    def set_softwareversion(self, *args):
        """set_softwareversion(self, char softwareversion)"""
        return _opensync.Version_set_softwareversion(self, *args)

    def set_hardwareversion(self, *args):
        """set_hardwareversion(self, char hardwareversion)"""
        return _opensync.Version_set_hardwareversion(self, *args)

    def set_identifier(self, *args):
        """set_identifier(self, char identifier)"""
        return _opensync.Version_set_identifier(self, *args)

    #	plugin = property(get_plugin, set_plugin)
    #	priority = property(get_priority, set_priority)
    #	vendor = property(get_vendor, set_vendor)
    #	modelversion = property(get_modelversion, set_modelversion)
    #	firmwareversion = property(get_firmwareversion, set_firmwareversion)
    #	softwareversion = property(get_softwareversion, set_softwareversion)
    #	hardwareversion = property(get_hardwareversion, set_hardwareversion)
    #	identifier = property(get_identifier, set_identifier)

Version_swigregister = _opensync.Version_swigregister
Version_swigregister(Version)