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





from sys import version_info
if version_info >= (3,0,0):
    new_instancemethod = lambda func, inst, cls: _pyadchpp.SWIG_PyInstanceMethod_New(func)
else:
    from new import instancemethod as new_instancemethod
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('_pyadchpp', [dirname(__file__)])
        except ImportError:
            import _pyadchpp
            return _pyadchpp
        if fp is not None:
            try:
                _mod = imp.load_module('_pyadchpp', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _pyadchpp = swig_import_helper()
    del swig_import_helper
else:
    import _pyadchpp
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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class SwigPyIterator(object):
    """Proxy of C++ swig::SwigPyIterator class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SwigPyIterator
    def value(self):
        """value(SwigPyIterator self) -> PyObject *"""
        return _pyadchpp.SwigPyIterator_value(self)

    def incr(self, n=1):
        """
        incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        incr(SwigPyIterator self) -> SwigPyIterator
        """
        return _pyadchpp.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        """
        decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
        decr(SwigPyIterator self) -> SwigPyIterator
        """
        return _pyadchpp.SwigPyIterator_decr(self, n)

    def distance(self, *args):
        """distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t"""
        return _pyadchpp.SwigPyIterator_distance(self, *args)

    def equal(self, *args):
        """equal(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pyadchpp.SwigPyIterator_equal(self, *args)

    def copy(self):
        """copy(SwigPyIterator self) -> SwigPyIterator"""
        return _pyadchpp.SwigPyIterator_copy(self)

    def next(self):
        """next(SwigPyIterator self) -> PyObject *"""
        return _pyadchpp.SwigPyIterator_next(self)

    def __next__(self):
        """__next__(SwigPyIterator self) -> PyObject *"""
        return _pyadchpp.SwigPyIterator___next__(self)

    def previous(self):
        """previous(SwigPyIterator self) -> PyObject *"""
        return _pyadchpp.SwigPyIterator_previous(self)

    def advance(self, *args):
        """advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pyadchpp.SwigPyIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pyadchpp.SwigPyIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(SwigPyIterator self, SwigPyIterator x) -> bool"""
        return _pyadchpp.SwigPyIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pyadchpp.SwigPyIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pyadchpp.SwigPyIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator"""
        return _pyadchpp.SwigPyIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
        __sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
        """
        return _pyadchpp.SwigPyIterator___sub__(self, *args)

    def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_pyadchpp.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_pyadchpp.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_pyadchpp.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_pyadchpp.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_pyadchpp.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_pyadchpp.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_pyadchpp.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_pyadchpp.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_pyadchpp.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_pyadchpp.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_pyadchpp.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_pyadchpp.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_pyadchpp.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_pyadchpp.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_pyadchpp.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_pyadchpp.SwigPyIterator___sub__,None,SwigPyIterator)
SwigPyIterator_swigregister = _pyadchpp.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


def new_size_t(*args):
  """new_size_t(size_t nelements) -> size_t *"""
  return _pyadchpp.new_size_t(*args)

def delete_size_t(*args):
  """delete_size_t(size_t * ary)"""
  return _pyadchpp.delete_size_t(*args)

def size_t_getitem(*args):
  """size_t_getitem(size_t * ary, size_t index) -> size_t"""
  return _pyadchpp.size_t_getitem(*args)

def size_t_setitem(*args):
  """size_t_setitem(size_t * ary, size_t index, size_t value)"""
  return _pyadchpp.size_t_setitem(*args)
class TServerInfoPtr(object):
    """Proxy of C++ shared_ptr<(adchpp::ServerInfo)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def __deref__(self):
        """__deref__(TServerInfoPtr self) -> ServerInfo"""
        return _pyadchpp.TServerInfoPtr___deref__(self)

    __swig_destroy__ = _pyadchpp.delete_TServerInfoPtr
    bind4 = _swig_property(_pyadchpp.TServerInfoPtr_bind4_get, _pyadchpp.TServerInfoPtr_bind4_set)
    bind6 = _swig_property(_pyadchpp.TServerInfoPtr_bind6_get, _pyadchpp.TServerInfoPtr_bind6_set)
    address4 = _swig_property(_pyadchpp.TServerInfoPtr_address4_get, _pyadchpp.TServerInfoPtr_address4_set)
    address6 = _swig_property(_pyadchpp.TServerInfoPtr_address6_get, _pyadchpp.TServerInfoPtr_address6_set)
    port = _swig_property(_pyadchpp.TServerInfoPtr_port_get, _pyadchpp.TServerInfoPtr_port_set)
    TLSParams = _swig_property(_pyadchpp.TServerInfoPtr_TLSParams_get, _pyadchpp.TServerInfoPtr_TLSParams_set)
    def secure(self):
        """secure(TServerInfoPtr self) -> bool"""
        return _pyadchpp.TServerInfoPtr_secure(self)

    def create(self):
        """create(TServerInfoPtr self) -> TServerInfoPtr"""
        return _pyadchpp.TServerInfoPtr_create(self)

TServerInfoPtr.__deref__ = new_instancemethod(_pyadchpp.TServerInfoPtr___deref__,None,TServerInfoPtr)
TServerInfoPtr.secure = new_instancemethod(_pyadchpp.TServerInfoPtr_secure,None,TServerInfoPtr)
TServerInfoPtr.create = new_instancemethod(_pyadchpp.TServerInfoPtr_create,None,TServerInfoPtr)
TServerInfoPtr_swigregister = _pyadchpp.TServerInfoPtr_swigregister
TServerInfoPtr_swigregister(TServerInfoPtr)

class TManagedConnectionPtr(object):
    """Proxy of C++ shared_ptr<(adchpp::ManagedConnection)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def __deref__(self):
        """__deref__(TManagedConnectionPtr self) -> ManagedConnection"""
        return _pyadchpp.TManagedConnectionPtr___deref__(self)

    __swig_destroy__ = _pyadchpp.delete_TManagedConnectionPtr
    def disconnect(self):
        """disconnect(TManagedConnectionPtr self)"""
        return _pyadchpp.TManagedConnectionPtr_disconnect(self)

    def release(self):
        """release(TManagedConnectionPtr self)"""
        return _pyadchpp.TManagedConnectionPtr_release(self)

TManagedConnectionPtr.__deref__ = new_instancemethod(_pyadchpp.TManagedConnectionPtr___deref__,None,TManagedConnectionPtr)
TManagedConnectionPtr.disconnect = new_instancemethod(_pyadchpp.TManagedConnectionPtr_disconnect,None,TManagedConnectionPtr)
TManagedConnectionPtr.release = new_instancemethod(_pyadchpp.TManagedConnectionPtr_release,None,TManagedConnectionPtr)
TManagedConnectionPtr_swigregister = _pyadchpp.TManagedConnectionPtr_swigregister
TManagedConnectionPtr_swigregister(TManagedConnectionPtr)

class TEntityList(object):
    """Proxy of C++ std::vector<(p.adchpp::Entity)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(TEntityList self) -> SwigPyIterator"""
        return _pyadchpp.TEntityList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(TEntityList self) -> bool"""
        return _pyadchpp.TEntityList___nonzero__(self)

    def __bool__(self):
        """__bool__(TEntityList self) -> bool"""
        return _pyadchpp.TEntityList___bool__(self)

    def __len__(self):
        """__len__(TEntityList self) -> std::vector< adchpp::Entity * >::size_type"""
        return _pyadchpp.TEntityList___len__(self)

    def pop(self):
        """pop(TEntityList self) -> Entity"""
        return _pyadchpp.TEntityList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(TEntityList self, std::vector< adchpp::Entity * >::difference_type i, std::vector< adchpp::Entity * >::difference_type j) -> TEntityList"""
        return _pyadchpp.TEntityList___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(TEntityList self, std::vector< adchpp::Entity * >::difference_type i, std::vector< adchpp::Entity * >::difference_type j, 
            TEntityList v=std::vector< adchpp::Entity *,std::allocator< adchpp::Entity * > >())
        __setslice__(TEntityList self, std::vector< adchpp::Entity * >::difference_type i, std::vector< adchpp::Entity * >::difference_type j)
        """
        return _pyadchpp.TEntityList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(TEntityList self, std::vector< adchpp::Entity * >::difference_type i, std::vector< adchpp::Entity * >::difference_type j)"""
        return _pyadchpp.TEntityList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(TEntityList self, std::vector< adchpp::Entity * >::difference_type i)
        __delitem__(TEntityList self, PySliceObject * slice)
        """
        return _pyadchpp.TEntityList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(TEntityList self, PySliceObject * slice) -> TEntityList
        __getitem__(TEntityList self, std::vector< adchpp::Entity * >::difference_type i) -> Entity
        """
        return _pyadchpp.TEntityList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(TEntityList self, PySliceObject * slice, TEntityList v)
        __setitem__(TEntityList self, PySliceObject * slice)
        __setitem__(TEntityList self, std::vector< adchpp::Entity * >::difference_type i, Entity x)
        """
        return _pyadchpp.TEntityList___setitem__(self, *args)

    def append(self, *args):
        """append(TEntityList self, Entity x)"""
        return _pyadchpp.TEntityList_append(self, *args)

    def empty(self):
        """empty(TEntityList self) -> bool"""
        return _pyadchpp.TEntityList_empty(self)

    def size(self):
        """size(TEntityList self) -> std::vector< adchpp::Entity * >::size_type"""
        return _pyadchpp.TEntityList_size(self)

    def clear(self):
        """clear(TEntityList self)"""
        return _pyadchpp.TEntityList_clear(self)

    def swap(self, *args):
        """swap(TEntityList self, TEntityList v)"""
        return _pyadchpp.TEntityList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(TEntityList self) -> std::vector< adchpp::Entity * >::allocator_type"""
        return _pyadchpp.TEntityList_get_allocator(self)

    def begin(self):
        """begin(TEntityList self) -> std::vector< adchpp::Entity * >::iterator"""
        return _pyadchpp.TEntityList_begin(self)

    def end(self):
        """end(TEntityList self) -> std::vector< adchpp::Entity * >::iterator"""
        return _pyadchpp.TEntityList_end(self)

    def rbegin(self):
        """rbegin(TEntityList self) -> std::vector< adchpp::Entity * >::reverse_iterator"""
        return _pyadchpp.TEntityList_rbegin(self)

    def rend(self):
        """rend(TEntityList self) -> std::vector< adchpp::Entity * >::reverse_iterator"""
        return _pyadchpp.TEntityList_rend(self)

    def pop_back(self):
        """pop_back(TEntityList self)"""
        return _pyadchpp.TEntityList_pop_back(self)

    def erase(self, *args):
        """
        erase(TEntityList self, std::vector< adchpp::Entity * >::iterator pos) -> std::vector< adchpp::Entity * >::iterator
        erase(TEntityList self, std::vector< adchpp::Entity * >::iterator first, std::vector< adchpp::Entity * >::iterator last) -> std::vector< adchpp::Entity * >::iterator
        """
        return _pyadchpp.TEntityList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(p.adchpp::Entity)> self) -> TEntityList
        __init__(std::vector<(p.adchpp::Entity)> self, TEntityList arg2) -> TEntityList
        __init__(std::vector<(p.adchpp::Entity)> self, std::vector< adchpp::Entity * >::size_type size) -> TEntityList
        __init__(std::vector<(p.adchpp::Entity)> self, std::vector< adchpp::Entity * >::size_type size, Entity value) -> TEntityList
        """
        _pyadchpp.TEntityList_swiginit(self,_pyadchpp.new_TEntityList(*args))
    def push_back(self, *args):
        """push_back(TEntityList self, Entity x)"""
        return _pyadchpp.TEntityList_push_back(self, *args)

    def front(self):
        """front(TEntityList self) -> Entity"""
        return _pyadchpp.TEntityList_front(self)

    def back(self):
        """back(TEntityList self) -> Entity"""
        return _pyadchpp.TEntityList_back(self)

    def assign(self, *args):
        """assign(TEntityList self, std::vector< adchpp::Entity * >::size_type n, Entity x)"""
        return _pyadchpp.TEntityList_assign(self, *args)

    def resize(self, *args):
        """
        resize(TEntityList self, std::vector< adchpp::Entity * >::size_type new_size)
        resize(TEntityList self, std::vector< adchpp::Entity * >::size_type new_size, Entity x)
        """
        return _pyadchpp.TEntityList_resize(self, *args)

    def insert(self, *args):
        """
        insert(TEntityList self, std::vector< adchpp::Entity * >::iterator pos, Entity x) -> std::vector< adchpp::Entity * >::iterator
        insert(TEntityList self, std::vector< adchpp::Entity * >::iterator pos, std::vector< adchpp::Entity * >::size_type n, 
            Entity x)
        """
        return _pyadchpp.TEntityList_insert(self, *args)

    def reserve(self, *args):
        """reserve(TEntityList self, std::vector< adchpp::Entity * >::size_type n)"""
        return _pyadchpp.TEntityList_reserve(self, *args)

    def capacity(self):
        """capacity(TEntityList self) -> std::vector< adchpp::Entity * >::size_type"""
        return _pyadchpp.TEntityList_capacity(self)

    __swig_destroy__ = _pyadchpp.delete_TEntityList
TEntityList.iterator = new_instancemethod(_pyadchpp.TEntityList_iterator,None,TEntityList)
TEntityList.__nonzero__ = new_instancemethod(_pyadchpp.TEntityList___nonzero__,None,TEntityList)
TEntityList.__bool__ = new_instancemethod(_pyadchpp.TEntityList___bool__,None,TEntityList)
TEntityList.__len__ = new_instancemethod(_pyadchpp.TEntityList___len__,None,TEntityList)
TEntityList.pop = new_instancemethod(_pyadchpp.TEntityList_pop,None,TEntityList)
TEntityList.__getslice__ = new_instancemethod(_pyadchpp.TEntityList___getslice__,None,TEntityList)
TEntityList.__setslice__ = new_instancemethod(_pyadchpp.TEntityList___setslice__,None,TEntityList)
TEntityList.__delslice__ = new_instancemethod(_pyadchpp.TEntityList___delslice__,None,TEntityList)
TEntityList.__delitem__ = new_instancemethod(_pyadchpp.TEntityList___delitem__,None,TEntityList)
TEntityList.__getitem__ = new_instancemethod(_pyadchpp.TEntityList___getitem__,None,TEntityList)
TEntityList.__setitem__ = new_instancemethod(_pyadchpp.TEntityList___setitem__,None,TEntityList)
TEntityList.append = new_instancemethod(_pyadchpp.TEntityList_append,None,TEntityList)
TEntityList.empty = new_instancemethod(_pyadchpp.TEntityList_empty,None,TEntityList)
TEntityList.size = new_instancemethod(_pyadchpp.TEntityList_size,None,TEntityList)
TEntityList.clear = new_instancemethod(_pyadchpp.TEntityList_clear,None,TEntityList)
TEntityList.swap = new_instancemethod(_pyadchpp.TEntityList_swap,None,TEntityList)
TEntityList.get_allocator = new_instancemethod(_pyadchpp.TEntityList_get_allocator,None,TEntityList)
TEntityList.begin = new_instancemethod(_pyadchpp.TEntityList_begin,None,TEntityList)
TEntityList.end = new_instancemethod(_pyadchpp.TEntityList_end,None,TEntityList)
TEntityList.rbegin = new_instancemethod(_pyadchpp.TEntityList_rbegin,None,TEntityList)
TEntityList.rend = new_instancemethod(_pyadchpp.TEntityList_rend,None,TEntityList)
TEntityList.pop_back = new_instancemethod(_pyadchpp.TEntityList_pop_back,None,TEntityList)
TEntityList.erase = new_instancemethod(_pyadchpp.TEntityList_erase,None,TEntityList)
TEntityList.push_back = new_instancemethod(_pyadchpp.TEntityList_push_back,None,TEntityList)
TEntityList.front = new_instancemethod(_pyadchpp.TEntityList_front,None,TEntityList)
TEntityList.back = new_instancemethod(_pyadchpp.TEntityList_back,None,TEntityList)
TEntityList.assign = new_instancemethod(_pyadchpp.TEntityList_assign,None,TEntityList)
TEntityList.resize = new_instancemethod(_pyadchpp.TEntityList_resize,None,TEntityList)
TEntityList.insert = new_instancemethod(_pyadchpp.TEntityList_insert,None,TEntityList)
TEntityList.reserve = new_instancemethod(_pyadchpp.TEntityList_reserve,None,TEntityList)
TEntityList.capacity = new_instancemethod(_pyadchpp.TEntityList_capacity,None,TEntityList)
TEntityList_swigregister = _pyadchpp.TEntityList_swigregister
TEntityList_swigregister(TEntityList)

class TStringList(object):
    """Proxy of C++ std::vector<(std::string)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(TStringList self) -> SwigPyIterator"""
        return _pyadchpp.TStringList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(TStringList self) -> bool"""
        return _pyadchpp.TStringList___nonzero__(self)

    def __bool__(self):
        """__bool__(TStringList self) -> bool"""
        return _pyadchpp.TStringList___bool__(self)

    def __len__(self):
        """__len__(TStringList self) -> std::vector< std::string >::size_type"""
        return _pyadchpp.TStringList___len__(self)

    def pop(self):
        """pop(TStringList self) -> std::vector< std::string >::value_type"""
        return _pyadchpp.TStringList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(TStringList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j) -> TStringList"""
        return _pyadchpp.TStringList___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(TStringList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j, 
            TStringList v=std::vector< std::string,std::allocator< std::string > >())
        __setslice__(TStringList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)
        """
        return _pyadchpp.TStringList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(TStringList self, std::vector< std::string >::difference_type i, std::vector< std::string >::difference_type j)"""
        return _pyadchpp.TStringList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(TStringList self, std::vector< std::string >::difference_type i)
        __delitem__(TStringList self, PySliceObject * slice)
        """
        return _pyadchpp.TStringList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(TStringList self, PySliceObject * slice) -> TStringList
        __getitem__(TStringList self, std::vector< std::string >::difference_type i) -> std::vector< std::string >::value_type const &
        """
        return _pyadchpp.TStringList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(TStringList self, PySliceObject * slice, TStringList v)
        __setitem__(TStringList self, PySliceObject * slice)
        __setitem__(TStringList self, std::vector< std::string >::difference_type i, std::vector< std::string >::value_type const & x)
        """
        return _pyadchpp.TStringList___setitem__(self, *args)

    def append(self, *args):
        """append(TStringList self, std::vector< std::string >::value_type const & x)"""
        return _pyadchpp.TStringList_append(self, *args)

    def empty(self):
        """empty(TStringList self) -> bool"""
        return _pyadchpp.TStringList_empty(self)

    def size(self):
        """size(TStringList self) -> std::vector< std::string >::size_type"""
        return _pyadchpp.TStringList_size(self)

    def clear(self):
        """clear(TStringList self)"""
        return _pyadchpp.TStringList_clear(self)

    def swap(self, *args):
        """swap(TStringList self, TStringList v)"""
        return _pyadchpp.TStringList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(TStringList self) -> std::vector< std::string >::allocator_type"""
        return _pyadchpp.TStringList_get_allocator(self)

    def begin(self):
        """begin(TStringList self) -> std::vector< std::string >::iterator"""
        return _pyadchpp.TStringList_begin(self)

    def end(self):
        """end(TStringList self) -> std::vector< std::string >::iterator"""
        return _pyadchpp.TStringList_end(self)

    def rbegin(self):
        """rbegin(TStringList self) -> std::vector< std::string >::reverse_iterator"""
        return _pyadchpp.TStringList_rbegin(self)

    def rend(self):
        """rend(TStringList self) -> std::vector< std::string >::reverse_iterator"""
        return _pyadchpp.TStringList_rend(self)

    def pop_back(self):
        """pop_back(TStringList self)"""
        return _pyadchpp.TStringList_pop_back(self)

    def erase(self, *args):
        """
        erase(TStringList self, std::vector< std::string >::iterator pos) -> std::vector< std::string >::iterator
        erase(TStringList self, std::vector< std::string >::iterator first, std::vector< std::string >::iterator last) -> std::vector< std::string >::iterator
        """
        return _pyadchpp.TStringList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(std::string)> self) -> TStringList
        __init__(std::vector<(std::string)> self, TStringList arg2) -> TStringList
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size) -> TStringList
        __init__(std::vector<(std::string)> self, std::vector< std::string >::size_type size, std::vector< std::string >::value_type const & value) -> TStringList
        """
        _pyadchpp.TStringList_swiginit(self,_pyadchpp.new_TStringList(*args))
    def push_back(self, *args):
        """push_back(TStringList self, std::vector< std::string >::value_type const & x)"""
        return _pyadchpp.TStringList_push_back(self, *args)

    def front(self):
        """front(TStringList self) -> std::vector< std::string >::value_type const &"""
        return _pyadchpp.TStringList_front(self)

    def back(self):
        """back(TStringList self) -> std::vector< std::string >::value_type const &"""
        return _pyadchpp.TStringList_back(self)

    def assign(self, *args):
        """assign(TStringList self, std::vector< std::string >::size_type n, std::vector< std::string >::value_type const & x)"""
        return _pyadchpp.TStringList_assign(self, *args)

    def resize(self, *args):
        """
        resize(TStringList self, std::vector< std::string >::size_type new_size)
        resize(TStringList self, std::vector< std::string >::size_type new_size, std::vector< std::string >::value_type const & x)
        """
        return _pyadchpp.TStringList_resize(self, *args)

    def insert(self, *args):
        """
        insert(TStringList self, std::vector< std::string >::iterator pos, std::vector< std::string >::value_type const & x) -> std::vector< std::string >::iterator
        insert(TStringList self, std::vector< std::string >::iterator pos, std::vector< std::string >::size_type n, 
            std::vector< std::string >::value_type const & x)
        """
        return _pyadchpp.TStringList_insert(self, *args)

    def reserve(self, *args):
        """reserve(TStringList self, std::vector< std::string >::size_type n)"""
        return _pyadchpp.TStringList_reserve(self, *args)

    def capacity(self):
        """capacity(TStringList self) -> std::vector< std::string >::size_type"""
        return _pyadchpp.TStringList_capacity(self)

    __swig_destroy__ = _pyadchpp.delete_TStringList
TStringList.iterator = new_instancemethod(_pyadchpp.TStringList_iterator,None,TStringList)
TStringList.__nonzero__ = new_instancemethod(_pyadchpp.TStringList___nonzero__,None,TStringList)
TStringList.__bool__ = new_instancemethod(_pyadchpp.TStringList___bool__,None,TStringList)
TStringList.__len__ = new_instancemethod(_pyadchpp.TStringList___len__,None,TStringList)
TStringList.pop = new_instancemethod(_pyadchpp.TStringList_pop,None,TStringList)
TStringList.__getslice__ = new_instancemethod(_pyadchpp.TStringList___getslice__,None,TStringList)
TStringList.__setslice__ = new_instancemethod(_pyadchpp.TStringList___setslice__,None,TStringList)
TStringList.__delslice__ = new_instancemethod(_pyadchpp.TStringList___delslice__,None,TStringList)
TStringList.__delitem__ = new_instancemethod(_pyadchpp.TStringList___delitem__,None,TStringList)
TStringList.__getitem__ = new_instancemethod(_pyadchpp.TStringList___getitem__,None,TStringList)
TStringList.__setitem__ = new_instancemethod(_pyadchpp.TStringList___setitem__,None,TStringList)
TStringList.append = new_instancemethod(_pyadchpp.TStringList_append,None,TStringList)
TStringList.empty = new_instancemethod(_pyadchpp.TStringList_empty,None,TStringList)
TStringList.size = new_instancemethod(_pyadchpp.TStringList_size,None,TStringList)
TStringList.clear = new_instancemethod(_pyadchpp.TStringList_clear,None,TStringList)
TStringList.swap = new_instancemethod(_pyadchpp.TStringList_swap,None,TStringList)
TStringList.get_allocator = new_instancemethod(_pyadchpp.TStringList_get_allocator,None,TStringList)
TStringList.begin = new_instancemethod(_pyadchpp.TStringList_begin,None,TStringList)
TStringList.end = new_instancemethod(_pyadchpp.TStringList_end,None,TStringList)
TStringList.rbegin = new_instancemethod(_pyadchpp.TStringList_rbegin,None,TStringList)
TStringList.rend = new_instancemethod(_pyadchpp.TStringList_rend,None,TStringList)
TStringList.pop_back = new_instancemethod(_pyadchpp.TStringList_pop_back,None,TStringList)
TStringList.erase = new_instancemethod(_pyadchpp.TStringList_erase,None,TStringList)
TStringList.push_back = new_instancemethod(_pyadchpp.TStringList_push_back,None,TStringList)
TStringList.front = new_instancemethod(_pyadchpp.TStringList_front,None,TStringList)
TStringList.back = new_instancemethod(_pyadchpp.TStringList_back,None,TStringList)
TStringList.assign = new_instancemethod(_pyadchpp.TStringList_assign,None,TStringList)
TStringList.resize = new_instancemethod(_pyadchpp.TStringList_resize,None,TStringList)
TStringList.insert = new_instancemethod(_pyadchpp.TStringList_insert,None,TStringList)
TStringList.reserve = new_instancemethod(_pyadchpp.TStringList_reserve,None,TStringList)
TStringList.capacity = new_instancemethod(_pyadchpp.TStringList_capacity,None,TStringList)
TStringList_swigregister = _pyadchpp.TStringList_swigregister
TStringList_swigregister(TStringList)

class TByteVector(object):
    """Proxy of C++ std::vector<(uint8_t)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(TByteVector self) -> SwigPyIterator"""
        return _pyadchpp.TByteVector_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(TByteVector self) -> bool"""
        return _pyadchpp.TByteVector___nonzero__(self)

    def __bool__(self):
        """__bool__(TByteVector self) -> bool"""
        return _pyadchpp.TByteVector___bool__(self)

    def __len__(self):
        """__len__(TByteVector self) -> std::vector< unsigned char >::size_type"""
        return _pyadchpp.TByteVector___len__(self)

    def pop(self):
        """pop(TByteVector self) -> std::vector< unsigned char >::value_type"""
        return _pyadchpp.TByteVector_pop(self)

    def __getslice__(self, *args):
        """__getslice__(TByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j) -> TByteVector"""
        return _pyadchpp.TByteVector___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(TByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j, 
            TByteVector v=std::vector< unsigned char,std::allocator< unsigned char > >())
        __setslice__(TByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)
        """
        return _pyadchpp.TByteVector___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(TByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::difference_type j)"""
        return _pyadchpp.TByteVector___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(TByteVector self, std::vector< unsigned char >::difference_type i)
        __delitem__(TByteVector self, PySliceObject * slice)
        """
        return _pyadchpp.TByteVector___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(TByteVector self, PySliceObject * slice) -> TByteVector
        __getitem__(TByteVector self, std::vector< unsigned char >::difference_type i) -> std::vector< unsigned char >::value_type const &
        """
        return _pyadchpp.TByteVector___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(TByteVector self, PySliceObject * slice, TByteVector v)
        __setitem__(TByteVector self, PySliceObject * slice)
        __setitem__(TByteVector self, std::vector< unsigned char >::difference_type i, std::vector< unsigned char >::value_type const & x)
        """
        return _pyadchpp.TByteVector___setitem__(self, *args)

    def append(self, *args):
        """append(TByteVector self, std::vector< unsigned char >::value_type const & x)"""
        return _pyadchpp.TByteVector_append(self, *args)

    def empty(self):
        """empty(TByteVector self) -> bool"""
        return _pyadchpp.TByteVector_empty(self)

    def size(self):
        """size(TByteVector self) -> std::vector< unsigned char >::size_type"""
        return _pyadchpp.TByteVector_size(self)

    def clear(self):
        """clear(TByteVector self)"""
        return _pyadchpp.TByteVector_clear(self)

    def swap(self, *args):
        """swap(TByteVector self, TByteVector v)"""
        return _pyadchpp.TByteVector_swap(self, *args)

    def get_allocator(self):
        """get_allocator(TByteVector self) -> std::vector< unsigned char >::allocator_type"""
        return _pyadchpp.TByteVector_get_allocator(self)

    def begin(self):
        """begin(TByteVector self) -> std::vector< unsigned char >::iterator"""
        return _pyadchpp.TByteVector_begin(self)

    def end(self):
        """end(TByteVector self) -> std::vector< unsigned char >::iterator"""
        return _pyadchpp.TByteVector_end(self)

    def rbegin(self):
        """rbegin(TByteVector self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pyadchpp.TByteVector_rbegin(self)

    def rend(self):
        """rend(TByteVector self) -> std::vector< unsigned char >::reverse_iterator"""
        return _pyadchpp.TByteVector_rend(self)

    def pop_back(self):
        """pop_back(TByteVector self)"""
        return _pyadchpp.TByteVector_pop_back(self)

    def erase(self, *args):
        """
        erase(TByteVector self, std::vector< unsigned char >::iterator pos) -> std::vector< unsigned char >::iterator
        erase(TByteVector self, std::vector< unsigned char >::iterator first, std::vector< unsigned char >::iterator last) -> std::vector< unsigned char >::iterator
        """
        return _pyadchpp.TByteVector_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(uint8_t)> self) -> TByteVector
        __init__(std::vector<(uint8_t)> self, TByteVector arg2) -> TByteVector
        __init__(std::vector<(uint8_t)> self, std::vector< unsigned char >::size_type size) -> TByteVector
        __init__(std::vector<(uint8_t)> self, std::vector< unsigned char >::size_type size, std::vector< unsigned char >::value_type const & value) -> TByteVector
        """
        _pyadchpp.TByteVector_swiginit(self,_pyadchpp.new_TByteVector(*args))
    def push_back(self, *args):
        """push_back(TByteVector self, std::vector< unsigned char >::value_type const & x)"""
        return _pyadchpp.TByteVector_push_back(self, *args)

    def front(self):
        """front(TByteVector self) -> std::vector< unsigned char >::value_type const &"""
        return _pyadchpp.TByteVector_front(self)

    def back(self):
        """back(TByteVector self) -> std::vector< unsigned char >::value_type const &"""
        return _pyadchpp.TByteVector_back(self)

    def assign(self, *args):
        """assign(TByteVector self, std::vector< unsigned char >::size_type n, std::vector< unsigned char >::value_type const & x)"""
        return _pyadchpp.TByteVector_assign(self, *args)

    def resize(self, *args):
        """
        resize(TByteVector self, std::vector< unsigned char >::size_type new_size)
        resize(TByteVector self, std::vector< unsigned char >::size_type new_size, std::vector< unsigned char >::value_type const & x)
        """
        return _pyadchpp.TByteVector_resize(self, *args)

    def insert(self, *args):
        """
        insert(TByteVector self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::value_type const & x) -> std::vector< unsigned char >::iterator
        insert(TByteVector self, std::vector< unsigned char >::iterator pos, std::vector< unsigned char >::size_type n, 
            std::vector< unsigned char >::value_type const & x)
        """
        return _pyadchpp.TByteVector_insert(self, *args)

    def reserve(self, *args):
        """reserve(TByteVector self, std::vector< unsigned char >::size_type n)"""
        return _pyadchpp.TByteVector_reserve(self, *args)

    def capacity(self):
        """capacity(TByteVector self) -> std::vector< unsigned char >::size_type"""
        return _pyadchpp.TByteVector_capacity(self)

    __swig_destroy__ = _pyadchpp.delete_TByteVector
TByteVector.iterator = new_instancemethod(_pyadchpp.TByteVector_iterator,None,TByteVector)
TByteVector.__nonzero__ = new_instancemethod(_pyadchpp.TByteVector___nonzero__,None,TByteVector)
TByteVector.__bool__ = new_instancemethod(_pyadchpp.TByteVector___bool__,None,TByteVector)
TByteVector.__len__ = new_instancemethod(_pyadchpp.TByteVector___len__,None,TByteVector)
TByteVector.pop = new_instancemethod(_pyadchpp.TByteVector_pop,None,TByteVector)
TByteVector.__getslice__ = new_instancemethod(_pyadchpp.TByteVector___getslice__,None,TByteVector)
TByteVector.__setslice__ = new_instancemethod(_pyadchpp.TByteVector___setslice__,None,TByteVector)
TByteVector.__delslice__ = new_instancemethod(_pyadchpp.TByteVector___delslice__,None,TByteVector)
TByteVector.__delitem__ = new_instancemethod(_pyadchpp.TByteVector___delitem__,None,TByteVector)
TByteVector.__getitem__ = new_instancemethod(_pyadchpp.TByteVector___getitem__,None,TByteVector)
TByteVector.__setitem__ = new_instancemethod(_pyadchpp.TByteVector___setitem__,None,TByteVector)
TByteVector.append = new_instancemethod(_pyadchpp.TByteVector_append,None,TByteVector)
TByteVector.empty = new_instancemethod(_pyadchpp.TByteVector_empty,None,TByteVector)
TByteVector.size = new_instancemethod(_pyadchpp.TByteVector_size,None,TByteVector)
TByteVector.clear = new_instancemethod(_pyadchpp.TByteVector_clear,None,TByteVector)
TByteVector.swap = new_instancemethod(_pyadchpp.TByteVector_swap,None,TByteVector)
TByteVector.get_allocator = new_instancemethod(_pyadchpp.TByteVector_get_allocator,None,TByteVector)
TByteVector.begin = new_instancemethod(_pyadchpp.TByteVector_begin,None,TByteVector)
TByteVector.end = new_instancemethod(_pyadchpp.TByteVector_end,None,TByteVector)
TByteVector.rbegin = new_instancemethod(_pyadchpp.TByteVector_rbegin,None,TByteVector)
TByteVector.rend = new_instancemethod(_pyadchpp.TByteVector_rend,None,TByteVector)
TByteVector.pop_back = new_instancemethod(_pyadchpp.TByteVector_pop_back,None,TByteVector)
TByteVector.erase = new_instancemethod(_pyadchpp.TByteVector_erase,None,TByteVector)
TByteVector.push_back = new_instancemethod(_pyadchpp.TByteVector_push_back,None,TByteVector)
TByteVector.front = new_instancemethod(_pyadchpp.TByteVector_front,None,TByteVector)
TByteVector.back = new_instancemethod(_pyadchpp.TByteVector_back,None,TByteVector)
TByteVector.assign = new_instancemethod(_pyadchpp.TByteVector_assign,None,TByteVector)
TByteVector.resize = new_instancemethod(_pyadchpp.TByteVector_resize,None,TByteVector)
TByteVector.insert = new_instancemethod(_pyadchpp.TByteVector_insert,None,TByteVector)
TByteVector.reserve = new_instancemethod(_pyadchpp.TByteVector_reserve,None,TByteVector)
TByteVector.capacity = new_instancemethod(_pyadchpp.TByteVector_capacity,None,TByteVector)
TByteVector_swigregister = _pyadchpp.TByteVector_swigregister
TByteVector_swigregister(TByteVector)

class TServerInfoList(object):
    """Proxy of C++ std::vector<(shared_ptr<(adchpp::ServerInfo)>)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(TServerInfoList self) -> SwigPyIterator"""
        return _pyadchpp.TServerInfoList_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(TServerInfoList self) -> bool"""
        return _pyadchpp.TServerInfoList___nonzero__(self)

    def __bool__(self):
        """__bool__(TServerInfoList self) -> bool"""
        return _pyadchpp.TServerInfoList___bool__(self)

    def __len__(self):
        """__len__(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::size_type"""
        return _pyadchpp.TServerInfoList___len__(self)

    def pop(self):
        """pop(TServerInfoList self) -> TServerInfoPtr"""
        return _pyadchpp.TServerInfoList_pop(self)

    def __getslice__(self, *args):
        """__getslice__(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type i, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type j) -> TServerInfoList"""
        return _pyadchpp.TServerInfoList___getslice__(self, *args)

    def __setslice__(self, *args):
        """
        __setslice__(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type i, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type j, 
            TServerInfoList v=std::vector< shared_ptr< adchpp::ServerInfo >,std::allocator< shared_ptr< adchpp::ServerInfo > > >())
        __setslice__(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type i, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type j)
        """
        return _pyadchpp.TServerInfoList___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type i, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type j)"""
        return _pyadchpp.TServerInfoList___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type i)
        __delitem__(TServerInfoList self, PySliceObject * slice)
        """
        return _pyadchpp.TServerInfoList___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(TServerInfoList self, PySliceObject * slice) -> TServerInfoList
        __getitem__(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type i) -> TServerInfoPtr
        """
        return _pyadchpp.TServerInfoList___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(TServerInfoList self, PySliceObject * slice, TServerInfoList v)
        __setitem__(TServerInfoList self, PySliceObject * slice)
        __setitem__(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::difference_type i, TServerInfoPtr x)
        """
        return _pyadchpp.TServerInfoList___setitem__(self, *args)

    def append(self, *args):
        """append(TServerInfoList self, TServerInfoPtr x)"""
        return _pyadchpp.TServerInfoList_append(self, *args)

    def empty(self):
        """empty(TServerInfoList self) -> bool"""
        return _pyadchpp.TServerInfoList_empty(self)

    def size(self):
        """size(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::size_type"""
        return _pyadchpp.TServerInfoList_size(self)

    def clear(self):
        """clear(TServerInfoList self)"""
        return _pyadchpp.TServerInfoList_clear(self)

    def swap(self, *args):
        """swap(TServerInfoList self, TServerInfoList v)"""
        return _pyadchpp.TServerInfoList_swap(self, *args)

    def get_allocator(self):
        """get_allocator(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::allocator_type"""
        return _pyadchpp.TServerInfoList_get_allocator(self)

    def begin(self):
        """begin(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::iterator"""
        return _pyadchpp.TServerInfoList_begin(self)

    def end(self):
        """end(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::iterator"""
        return _pyadchpp.TServerInfoList_end(self)

    def rbegin(self):
        """rbegin(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::reverse_iterator"""
        return _pyadchpp.TServerInfoList_rbegin(self)

    def rend(self):
        """rend(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::reverse_iterator"""
        return _pyadchpp.TServerInfoList_rend(self)

    def pop_back(self):
        """pop_back(TServerInfoList self)"""
        return _pyadchpp.TServerInfoList_pop_back(self)

    def erase(self, *args):
        """
        erase(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::iterator pos) -> std::vector< shared_ptr< adchpp::ServerInfo > >::iterator
        erase(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::iterator first, std::vector< shared_ptr< adchpp::ServerInfo > >::iterator last) -> std::vector< shared_ptr< adchpp::ServerInfo > >::iterator
        """
        return _pyadchpp.TServerInfoList_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(std::vector<(shared_ptr<(adchpp::ServerInfo)>)> self) -> TServerInfoList
        __init__(std::vector<(shared_ptr<(adchpp::ServerInfo)>)> self, TServerInfoList arg2) -> TServerInfoList
        __init__(std::vector<(shared_ptr<(adchpp::ServerInfo)>)> self, std::vector< shared_ptr< adchpp::ServerInfo > >::size_type size) -> TServerInfoList
        __init__(std::vector<(shared_ptr<(adchpp::ServerInfo)>)> self, std::vector< shared_ptr< adchpp::ServerInfo > >::size_type size, TServerInfoPtr value) -> TServerInfoList
        """
        _pyadchpp.TServerInfoList_swiginit(self,_pyadchpp.new_TServerInfoList(*args))
    def push_back(self, *args):
        """push_back(TServerInfoList self, TServerInfoPtr x)"""
        return _pyadchpp.TServerInfoList_push_back(self, *args)

    def front(self):
        """front(TServerInfoList self) -> TServerInfoPtr"""
        return _pyadchpp.TServerInfoList_front(self)

    def back(self):
        """back(TServerInfoList self) -> TServerInfoPtr"""
        return _pyadchpp.TServerInfoList_back(self)

    def assign(self, *args):
        """assign(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::size_type n, TServerInfoPtr x)"""
        return _pyadchpp.TServerInfoList_assign(self, *args)

    def resize(self, *args):
        """
        resize(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::size_type new_size)
        resize(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::size_type new_size, TServerInfoPtr x)
        """
        return _pyadchpp.TServerInfoList_resize(self, *args)

    def insert(self, *args):
        """
        insert(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::iterator pos, TServerInfoPtr x) -> std::vector< shared_ptr< adchpp::ServerInfo > >::iterator
        insert(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::iterator pos, std::vector< shared_ptr< adchpp::ServerInfo > >::size_type n, 
            TServerInfoPtr x)
        """
        return _pyadchpp.TServerInfoList_insert(self, *args)

    def reserve(self, *args):
        """reserve(TServerInfoList self, std::vector< shared_ptr< adchpp::ServerInfo > >::size_type n)"""
        return _pyadchpp.TServerInfoList_reserve(self, *args)

    def capacity(self):
        """capacity(TServerInfoList self) -> std::vector< shared_ptr< adchpp::ServerInfo > >::size_type"""
        return _pyadchpp.TServerInfoList_capacity(self)

    __swig_destroy__ = _pyadchpp.delete_TServerInfoList
TServerInfoList.iterator = new_instancemethod(_pyadchpp.TServerInfoList_iterator,None,TServerInfoList)
TServerInfoList.__nonzero__ = new_instancemethod(_pyadchpp.TServerInfoList___nonzero__,None,TServerInfoList)
TServerInfoList.__bool__ = new_instancemethod(_pyadchpp.TServerInfoList___bool__,None,TServerInfoList)
TServerInfoList.__len__ = new_instancemethod(_pyadchpp.TServerInfoList___len__,None,TServerInfoList)
TServerInfoList.pop = new_instancemethod(_pyadchpp.TServerInfoList_pop,None,TServerInfoList)
TServerInfoList.__getslice__ = new_instancemethod(_pyadchpp.TServerInfoList___getslice__,None,TServerInfoList)
TServerInfoList.__setslice__ = new_instancemethod(_pyadchpp.TServerInfoList___setslice__,None,TServerInfoList)
TServerInfoList.__delslice__ = new_instancemethod(_pyadchpp.TServerInfoList___delslice__,None,TServerInfoList)
TServerInfoList.__delitem__ = new_instancemethod(_pyadchpp.TServerInfoList___delitem__,None,TServerInfoList)
TServerInfoList.__getitem__ = new_instancemethod(_pyadchpp.TServerInfoList___getitem__,None,TServerInfoList)
TServerInfoList.__setitem__ = new_instancemethod(_pyadchpp.TServerInfoList___setitem__,None,TServerInfoList)
TServerInfoList.append = new_instancemethod(_pyadchpp.TServerInfoList_append,None,TServerInfoList)
TServerInfoList.empty = new_instancemethod(_pyadchpp.TServerInfoList_empty,None,TServerInfoList)
TServerInfoList.size = new_instancemethod(_pyadchpp.TServerInfoList_size,None,TServerInfoList)
TServerInfoList.clear = new_instancemethod(_pyadchpp.TServerInfoList_clear,None,TServerInfoList)
TServerInfoList.swap = new_instancemethod(_pyadchpp.TServerInfoList_swap,None,TServerInfoList)
TServerInfoList.get_allocator = new_instancemethod(_pyadchpp.TServerInfoList_get_allocator,None,TServerInfoList)
TServerInfoList.begin = new_instancemethod(_pyadchpp.TServerInfoList_begin,None,TServerInfoList)
TServerInfoList.end = new_instancemethod(_pyadchpp.TServerInfoList_end,None,TServerInfoList)
TServerInfoList.rbegin = new_instancemethod(_pyadchpp.TServerInfoList_rbegin,None,TServerInfoList)
TServerInfoList.rend = new_instancemethod(_pyadchpp.TServerInfoList_rend,None,TServerInfoList)
TServerInfoList.pop_back = new_instancemethod(_pyadchpp.TServerInfoList_pop_back,None,TServerInfoList)
TServerInfoList.erase = new_instancemethod(_pyadchpp.TServerInfoList_erase,None,TServerInfoList)
TServerInfoList.push_back = new_instancemethod(_pyadchpp.TServerInfoList_push_back,None,TServerInfoList)
TServerInfoList.front = new_instancemethod(_pyadchpp.TServerInfoList_front,None,TServerInfoList)
TServerInfoList.back = new_instancemethod(_pyadchpp.TServerInfoList_back,None,TServerInfoList)
TServerInfoList.assign = new_instancemethod(_pyadchpp.TServerInfoList_assign,None,TServerInfoList)
TServerInfoList.resize = new_instancemethod(_pyadchpp.TServerInfoList_resize,None,TServerInfoList)
TServerInfoList.insert = new_instancemethod(_pyadchpp.TServerInfoList_insert,None,TServerInfoList)
TServerInfoList.reserve = new_instancemethod(_pyadchpp.TServerInfoList_reserve,None,TServerInfoList)
TServerInfoList.capacity = new_instancemethod(_pyadchpp.TServerInfoList_capacity,None,TServerInfoList)
TServerInfoList_swigregister = _pyadchpp.TServerInfoList_swigregister
TServerInfoList_swigregister(TServerInfoList)

class TLSInfo(object):
    """Proxy of C++ TLSInfo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    cert = _swig_property(_pyadchpp.TLSInfo_cert_get, _pyadchpp.TLSInfo_cert_set)
    pkey = _swig_property(_pyadchpp.TLSInfo_pkey_get, _pyadchpp.TLSInfo_pkey_set)
    trustedPath = _swig_property(_pyadchpp.TLSInfo_trustedPath_get, _pyadchpp.TLSInfo_trustedPath_set)
    dh = _swig_property(_pyadchpp.TLSInfo_dh_get, _pyadchpp.TLSInfo_dh_set)
    __swig_destroy__ = _pyadchpp.delete_TLSInfo
TLSInfo_swigregister = _pyadchpp.TLSInfo_swigregister
TLSInfo_swigregister(TLSInfo)

class Buffer(object):
    """Proxy of C++ adchpp::Buffer class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def create(*args):
        """create(std::string const & s) -> shared_ptr< adchpp::Buffer >"""
        return _pyadchpp.Buffer_create(*args)

    create = staticmethod(create)
    __swig_destroy__ = _pyadchpp.delete_Buffer
Buffer_swigregister = _pyadchpp.Buffer_swigregister
Buffer_swigregister(Buffer)
cvar = _pyadchpp.cvar

def Buffer_create(*args):
  """Buffer_create(std::string const & s) -> shared_ptr< adchpp::Buffer >"""
  return _pyadchpp.Buffer_create(*args)

class ManagedConnection(object):
    """Proxy of C++ adchpp::ManagedConnection class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def disconnect(self):
        """disconnect(ManagedConnection self)"""
        return _pyadchpp.ManagedConnection_disconnect(self)

    def release(self):
        """release(ManagedConnection self)"""
        return _pyadchpp.ManagedConnection_release(self)

    __swig_destroy__ = _pyadchpp.delete_ManagedConnection
ManagedConnection.disconnect = new_instancemethod(_pyadchpp.ManagedConnection_disconnect,None,ManagedConnection)
ManagedConnection.release = new_instancemethod(_pyadchpp.ManagedConnection_release,None,ManagedConnection)
ManagedConnection_swigregister = _pyadchpp.ManagedConnection_swigregister
ManagedConnection_swigregister(ManagedConnection)

class ServerInfo(object):
    """Proxy of C++ adchpp::ServerInfo class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    bind4 = _swig_property(_pyadchpp.ServerInfo_bind4_get, _pyadchpp.ServerInfo_bind4_set)
    bind6 = _swig_property(_pyadchpp.ServerInfo_bind6_get, _pyadchpp.ServerInfo_bind6_set)
    address4 = _swig_property(_pyadchpp.ServerInfo_address4_get, _pyadchpp.ServerInfo_address4_set)
    address6 = _swig_property(_pyadchpp.ServerInfo_address6_get, _pyadchpp.ServerInfo_address6_set)
    port = _swig_property(_pyadchpp.ServerInfo_port_get, _pyadchpp.ServerInfo_port_set)
    TLSParams = _swig_property(_pyadchpp.ServerInfo_TLSParams_get, _pyadchpp.ServerInfo_TLSParams_set)
    def secure(self):
        """secure(ServerInfo self) -> bool"""
        return _pyadchpp.ServerInfo_secure(self)

    def create():
        """create() -> TServerInfoPtr"""
        return _pyadchpp.ServerInfo_create()

    create = staticmethod(create)
    __swig_destroy__ = _pyadchpp.delete_ServerInfo
ServerInfo.secure = new_instancemethod(_pyadchpp.ServerInfo_secure,None,ServerInfo)
ServerInfo_swigregister = _pyadchpp.ServerInfo_swigregister
ServerInfo_swigregister(ServerInfo)

def ServerInfo_create():
  """ServerInfo_create() -> TServerInfoPtr"""
  return _pyadchpp.ServerInfo_create()

class SocketStats(object):
    """Proxy of C++ adchpp::SocketStats class"""
    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__(adchpp::SocketStats self) -> SocketStats"""
        _pyadchpp.SocketStats_swiginit(self,_pyadchpp.new_SocketStats())
    queueCalls = _swig_property(_pyadchpp.SocketStats_queueCalls_get, _pyadchpp.SocketStats_queueCalls_set)
    queueBytes = _swig_property(_pyadchpp.SocketStats_queueBytes_get, _pyadchpp.SocketStats_queueBytes_set)
    sendCalls = _swig_property(_pyadchpp.SocketStats_sendCalls_get, _pyadchpp.SocketStats_sendCalls_set)
    sendBytes = _swig_property(_pyadchpp.SocketStats_sendBytes_get, _pyadchpp.SocketStats_sendBytes_set)
    recvCalls = _swig_property(_pyadchpp.SocketStats_recvCalls_get, _pyadchpp.SocketStats_recvCalls_set)
    recvBytes = _swig_property(_pyadchpp.SocketStats_recvBytes_get, _pyadchpp.SocketStats_recvBytes_set)
    __swig_destroy__ = _pyadchpp.delete_SocketStats
SocketStats_swigregister = _pyadchpp.SocketStats_swigregister
SocketStats_swigregister(SocketStats)

class SocketManager(object):
    """Proxy of C++ adchpp::SocketManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def addJob(self, *args):
        """addJob(SocketManager self, long const msec, adchpp::SocketManager::Callback callback)"""
        return _pyadchpp.SocketManager_addJob(self, *args)

    def addJob_str(self, *args):
        """addJob_str(SocketManager self, std::string const & time, adchpp::SocketManager::Callback callback)"""
        return _pyadchpp.SocketManager_addJob_str(self, *args)

    def addTimedJob(self, *args):
        """addTimedJob(SocketManager self, long const msec, adchpp::SocketManager::Callback callback) -> adchpp::SocketManager::Callback"""
        return _pyadchpp.SocketManager_addTimedJob(self, *args)

    def addTimedJob_str(self, *args):
        """addTimedJob_str(SocketManager self, std::string const & time, adchpp::SocketManager::Callback callback) -> adchpp::SocketManager::Callback"""
        return _pyadchpp.SocketManager_addTimedJob_str(self, *args)

    def setBufferSize(self, *args):
        """setBufferSize(SocketManager self, size_t newSize)"""
        return _pyadchpp.SocketManager_setBufferSize(self, *args)

    def getBufferSize(self):
        """getBufferSize(SocketManager self) -> size_t"""
        return _pyadchpp.SocketManager_getBufferSize(self)

    def setMaxBufferSize(self, *args):
        """setMaxBufferSize(SocketManager self, size_t newSize)"""
        return _pyadchpp.SocketManager_setMaxBufferSize(self, *args)

    def getMaxBufferSize(self):
        """getMaxBufferSize(SocketManager self) -> size_t"""
        return _pyadchpp.SocketManager_getMaxBufferSize(self)

    def setOverflowTimeout(self, *args):
        """setOverflowTimeout(SocketManager self, size_t timeout)"""
        return _pyadchpp.SocketManager_setOverflowTimeout(self, *args)

    def getOverflowTimeout(self):
        """getOverflowTimeout(SocketManager self) -> size_t"""
        return _pyadchpp.SocketManager_getOverflowTimeout(self)

    def setDisconnectTimeout(self, *args):
        """setDisconnectTimeout(SocketManager self, size_t timeout)"""
        return _pyadchpp.SocketManager_setDisconnectTimeout(self, *args)

    def getDisconnectTimeout(self):
        """getDisconnectTimeout(SocketManager self) -> size_t"""
        return _pyadchpp.SocketManager_getDisconnectTimeout(self)

    def setServers(self, *args):
        """setServers(SocketManager self, TServerInfoList servers_)"""
        return _pyadchpp.SocketManager_setServers(self, *args)

    def getStats(self):
        """getStats(SocketManager self) -> SocketStats"""
        return _pyadchpp.SocketManager_getStats(self)

SocketManager.addJob = new_instancemethod(_pyadchpp.SocketManager_addJob,None,SocketManager)
SocketManager.addJob_str = new_instancemethod(_pyadchpp.SocketManager_addJob_str,None,SocketManager)
SocketManager.addTimedJob = new_instancemethod(_pyadchpp.SocketManager_addTimedJob,None,SocketManager)
SocketManager.addTimedJob_str = new_instancemethod(_pyadchpp.SocketManager_addTimedJob_str,None,SocketManager)
SocketManager.setBufferSize = new_instancemethod(_pyadchpp.SocketManager_setBufferSize,None,SocketManager)
SocketManager.getBufferSize = new_instancemethod(_pyadchpp.SocketManager_getBufferSize,None,SocketManager)
SocketManager.setMaxBufferSize = new_instancemethod(_pyadchpp.SocketManager_setMaxBufferSize,None,SocketManager)
SocketManager.getMaxBufferSize = new_instancemethod(_pyadchpp.SocketManager_getMaxBufferSize,None,SocketManager)
SocketManager.setOverflowTimeout = new_instancemethod(_pyadchpp.SocketManager_setOverflowTimeout,None,SocketManager)
SocketManager.getOverflowTimeout = new_instancemethod(_pyadchpp.SocketManager_getOverflowTimeout,None,SocketManager)
SocketManager.setDisconnectTimeout = new_instancemethod(_pyadchpp.SocketManager_setDisconnectTimeout,None,SocketManager)
SocketManager.getDisconnectTimeout = new_instancemethod(_pyadchpp.SocketManager_getDisconnectTimeout,None,SocketManager)
SocketManager.setServers = new_instancemethod(_pyadchpp.SocketManager_setServers,None,SocketManager)
SocketManager.getStats = new_instancemethod(_pyadchpp.SocketManager_getStats,None,SocketManager)
SocketManager_swigregister = _pyadchpp.SocketManager_swigregister
SocketManager_swigregister(SocketManager)

class Exception(object):
    """Proxy of C++ adchpp::Exception class"""
    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__(adchpp::Exception self) -> Exception
        __init__(adchpp::Exception self, std::string const & aError) -> Exception
        """
        _pyadchpp.Exception_swiginit(self,_pyadchpp.new_Exception(*args))
    __swig_destroy__ = _pyadchpp.delete_Exception
    def getError(self):
        """getError(Exception self) -> std::string const &"""
        return _pyadchpp.Exception_getError(self)

    def what(self):
        """what(Exception self) -> char const *"""
        return _pyadchpp.Exception_what(self)

    error = property(getError) 
Exception.getError = new_instancemethod(_pyadchpp.Exception_getError,None,Exception)
Exception.what = new_instancemethod(_pyadchpp.Exception_what,None,Exception)
Exception_swigregister = _pyadchpp.Exception_swigregister
Exception_swigregister(Exception)

class Text(object):
    """Proxy of C++ adchpp::Text class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def acpToUtf8(*args):
        """acpToUtf8(std::string const & str) -> std::string"""
        return _pyadchpp.Text_acpToUtf8(*args)

    acpToUtf8 = staticmethod(acpToUtf8)
    def acpToWide(*args):
        """acpToWide(std::string const & str) -> std::wstring"""
        return _pyadchpp.Text_acpToWide(*args)

    acpToWide = staticmethod(acpToWide)
    def utf8ToAcp(*args):
        """utf8ToAcp(std::string const & str) -> std::string"""
        return _pyadchpp.Text_utf8ToAcp(*args)

    utf8ToAcp = staticmethod(utf8ToAcp)
    def utf8ToWide(*args):
        """utf8ToWide(std::string const & str) -> std::wstring"""
        return _pyadchpp.Text_utf8ToWide(*args)

    utf8ToWide = staticmethod(utf8ToWide)
    def wideToAcp(*args):
        """wideToAcp(std::wstring const & str) -> std::string"""
        return _pyadchpp.Text_wideToAcp(*args)

    wideToAcp = staticmethod(wideToAcp)
    def wideToUtf8(*args):
        """wideToUtf8(std::wstring const & str) -> std::string"""
        return _pyadchpp.Text_wideToUtf8(*args)

    wideToUtf8 = staticmethod(wideToUtf8)
    def validateUtf8(*args):
        """validateUtf8(std::string const & str) -> bool"""
        return _pyadchpp.Text_validateUtf8(*args)

    validateUtf8 = staticmethod(validateUtf8)
Text_swigregister = _pyadchpp.Text_swigregister
Text_swigregister(Text)

def Text_acpToUtf8(*args):
  """Text_acpToUtf8(std::string const & str) -> std::string"""
  return _pyadchpp.Text_acpToUtf8(*args)

def Text_acpToWide(*args):
  """Text_acpToWide(std::string const & str) -> std::wstring"""
  return _pyadchpp.Text_acpToWide(*args)

def Text_utf8ToAcp(*args):
  """Text_utf8ToAcp(std::string const & str) -> std::string"""
  return _pyadchpp.Text_utf8ToAcp(*args)

def Text_utf8ToWide(*args):
  """Text_utf8ToWide(std::string const & str) -> std::wstring"""
  return _pyadchpp.Text_utf8ToWide(*args)

def Text_wideToAcp(*args):
  """Text_wideToAcp(std::wstring const & str) -> std::string"""
  return _pyadchpp.Text_wideToAcp(*args)

def Text_wideToUtf8(*args):
  """Text_wideToUtf8(std::wstring const & str) -> std::string"""
  return _pyadchpp.Text_wideToUtf8(*args)

def Text_validateUtf8(*args):
  """Text_validateUtf8(std::string const & str) -> bool"""
  return _pyadchpp.Text_validateUtf8(*args)

class Util(object):
    """Proxy of C++ adchpp::Util class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    REASON_BAD_STATE = _pyadchpp.Util_REASON_BAD_STATE
    REASON_CID_CHANGE = _pyadchpp.Util_REASON_CID_CHANGE
    REASON_CID_TAKEN = _pyadchpp.Util_REASON_CID_TAKEN
    REASON_FLOODING = _pyadchpp.Util_REASON_FLOODING
    REASON_HUB_FULL = _pyadchpp.Util_REASON_HUB_FULL
    REASON_INVALID_COMMAND_TYPE = _pyadchpp.Util_REASON_INVALID_COMMAND_TYPE
    REASON_INVALID_IP = _pyadchpp.Util_REASON_INVALID_IP
    REASON_INVALID_SID = _pyadchpp.Util_REASON_INVALID_SID
    REASON_LOGIN_TIMEOUT = _pyadchpp.Util_REASON_LOGIN_TIMEOUT
    REASON_MAX_COMMAND_SIZE = _pyadchpp.Util_REASON_MAX_COMMAND_SIZE
    REASON_NICK_INVALID = _pyadchpp.Util_REASON_NICK_INVALID
    REASON_NICK_TAKEN = _pyadchpp.Util_REASON_NICK_TAKEN
    REASON_NO_BASE_SUPPORT = _pyadchpp.Util_REASON_NO_BASE_SUPPORT
    REASON_NO_TIGR_SUPPORT = _pyadchpp.Util_REASON_NO_TIGR_SUPPORT
    REASON_PID_MISSING = _pyadchpp.Util_REASON_PID_MISSING
    REASON_PID_CID_LENGTH = _pyadchpp.Util_REASON_PID_CID_LENGTH
    REASON_PID_CID_MISMATCH = _pyadchpp.Util_REASON_PID_CID_MISMATCH
    REASON_PID_WITHOUT_CID = _pyadchpp.Util_REASON_PID_WITHOUT_CID
    REASON_PLUGIN = _pyadchpp.Util_REASON_PLUGIN
    REASON_WRITE_OVERFLOW = _pyadchpp.Util_REASON_WRITE_OVERFLOW
    REASON_NO_BANDWIDTH = _pyadchpp.Util_REASON_NO_BANDWIDTH
    REASON_INVALID_DESCRIPTION = _pyadchpp.Util_REASON_INVALID_DESCRIPTION
    REASON_WRITE_TIMEOUT = _pyadchpp.Util_REASON_WRITE_TIMEOUT
    REASON_SOCKET_ERROR = _pyadchpp.Util_REASON_SOCKET_ERROR
    REASON_LAST = _pyadchpp.Util_REASON_LAST
    emptyString = _swig_property(_pyadchpp.Util_emptyString_get, _pyadchpp.Util_emptyString_set)
    def getOsVersion():
        """getOsVersion() -> std::string"""
        return _pyadchpp.Util_getOsVersion()

    getOsVersion = staticmethod(getOsVersion)
    def decodeUrl(*args):
        """decodeUrl(std::string const & aUrl, std::string & aServer, short & aPort, std::string & aFile)"""
        return _pyadchpp.Util_decodeUrl(*args)

    decodeUrl = staticmethod(decodeUrl)
    def formatTime(*args):
        """
        formatTime(std::string const & msg, time_t t=time(NULL)) -> std::string
        formatTime(std::string const & msg) -> std::string
        """
        return _pyadchpp.Util_formatTime(*args)

    formatTime = staticmethod(formatTime)
    def getAppPath():
        """getAppPath() -> std::string"""
        return _pyadchpp.Util_getAppPath()

    getAppPath = staticmethod(getAppPath)
    def getAppName():
        """getAppName() -> std::string"""
        return _pyadchpp.Util_getAppName()

    getAppName = staticmethod(getAppName)
    def translateError(*args):
        """translateError(int aError) -> std::string"""
        return _pyadchpp.Util_translateError(*args)

    translateError = staticmethod(translateError)
    def getShortTimeString():
        """getShortTimeString() -> std::string"""
        return _pyadchpp.Util_getShortTimeString()

    getShortTimeString = staticmethod(getShortTimeString)
    def getTimeString():
        """getTimeString() -> std::string"""
        return _pyadchpp.Util_getTimeString()

    getTimeString = staticmethod(getTimeString)
    def formatBytes(*args):
        """
        formatBytes(std::string const & aString) -> std::string
        formatBytes(int64_t aBytes) -> std::string
        """
        return _pyadchpp.Util_formatBytes(*args)

    formatBytes = staticmethod(formatBytes)
    def tokenize(*args):
        """
        tokenize(TStringList lst, std::string const & str, char sep, std::string::size_type j=0)
        tokenize(TStringList lst, std::string const & str, char sep)
        """
        return _pyadchpp.Util_tokenize(*args)

    tokenize = staticmethod(tokenize)
    def formatSeconds(*args):
        """formatSeconds(int64_t aSec) -> std::string"""
        return _pyadchpp.Util_formatSeconds(*args)

    formatSeconds = staticmethod(formatSeconds)
    def getLocalIp():
        """getLocalIp() -> std::string"""
        return _pyadchpp.Util_getLocalIp()

    getLocalIp = staticmethod(getLocalIp)
    def rand(*args):
        """
        rand() -> uint32_t
        rand(uint32_t high) -> uint32_t
        rand(uint32_t low, uint32_t high) -> uint32_t
        """
        return _pyadchpp.Util_rand(*args)

    rand = staticmethod(rand)
    def randd():
        """randd() -> double"""
        return _pyadchpp.Util_randd()

    randd = staticmethod(randd)
    def isPrivateIp(*args):
        """isPrivateIp(std::string const & ip, bool v6) -> bool"""
        return _pyadchpp.Util_isPrivateIp(*args)

    isPrivateIp = staticmethod(isPrivateIp)
    def validateCharset(*args):
        """validateCharset(std::string const & field, int p) -> bool"""
        return _pyadchpp.Util_validateCharset(*args)

    validateCharset = staticmethod(validateCharset)
Util_swigregister = _pyadchpp.Util_swigregister
Util_swigregister(Util)

def Util_getOsVersion():
  """Util_getOsVersion() -> std::string"""
  return _pyadchpp.Util_getOsVersion()

def Util_decodeUrl(*args):
  """Util_decodeUrl(std::string const & aUrl, std::string & aServer, short & aPort, std::string & aFile)"""
  return _pyadchpp.Util_decodeUrl(*args)

def Util_formatTime(*args):
  """
    formatTime(std::string const & msg, time_t t=time(NULL)) -> std::string
    Util_formatTime(std::string const & msg) -> std::string
    """
  return _pyadchpp.Util_formatTime(*args)

def Util_getAppPath():
  """Util_getAppPath() -> std::string"""
  return _pyadchpp.Util_getAppPath()

def Util_getAppName():
  """Util_getAppName() -> std::string"""
  return _pyadchpp.Util_getAppName()

def Util_translateError(*args):
  """Util_translateError(int aError) -> std::string"""
  return _pyadchpp.Util_translateError(*args)

def Util_getShortTimeString():
  """Util_getShortTimeString() -> std::string"""
  return _pyadchpp.Util_getShortTimeString()

def Util_getTimeString():
  """Util_getTimeString() -> std::string"""
  return _pyadchpp.Util_getTimeString()

def Util_formatBytes(*args):
  """
    formatBytes(std::string const & aString) -> std::string
    Util_formatBytes(int64_t aBytes) -> std::string
    """
  return _pyadchpp.Util_formatBytes(*args)

def Util_tokenize(*args):
  """
    tokenize(TStringList lst, std::string const & str, char sep, std::string::size_type j=0)
    Util_tokenize(TStringList lst, std::string const & str, char sep)
    """
  return _pyadchpp.Util_tokenize(*args)

def Util_formatSeconds(*args):
  """Util_formatSeconds(int64_t aSec) -> std::string"""
  return _pyadchpp.Util_formatSeconds(*args)

def Util_getLocalIp():
  """Util_getLocalIp() -> std::string"""
  return _pyadchpp.Util_getLocalIp()

def Util_rand(*args):
  """
    rand() -> uint32_t
    rand(uint32_t high) -> uint32_t
    Util_rand(uint32_t low, uint32_t high) -> uint32_t
    """
  return _pyadchpp.Util_rand(*args)

def Util_randd():
  """Util_randd() -> double"""
  return _pyadchpp.Util_randd()

def Util_isPrivateIp(*args):
  """Util_isPrivateIp(std::string const & ip, bool v6) -> bool"""
  return _pyadchpp.Util_isPrivateIp(*args)

def Util_validateCharset(*args):
  """Util_validateCharset(std::string const & field, int p) -> bool"""
  return _pyadchpp.Util_validateCharset(*args)

class CID(object):
    """Proxy of C++ adchpp::CID class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    SIZE = _pyadchpp.CID_SIZE
    BASE32_SIZE = _pyadchpp.CID_BASE32_SIZE
    def __init__(self, *args): 
        """
        __init__(adchpp::CID self) -> CID
        __init__(adchpp::CID self, uint8_t const * data) -> CID
        __init__(adchpp::CID self, std::string const & base32) -> CID
        """
        _pyadchpp.CID_swiginit(self,_pyadchpp.new_CID(*args))
    def __eq__(self, *args):
        """__eq__(CID self, CID rhs) -> bool"""
        return _pyadchpp.CID___eq__(self, *args)

    def __lt__(self, *args):
        """__lt__(CID self, CID rhs) -> bool"""
        return _pyadchpp.CID___lt__(self, *args)

    def toBase32(self):
        """toBase32(CID self) -> std::string"""
        return _pyadchpp.CID_toBase32(self)

    def toHash(self):
        """toHash(CID self) -> size_t"""
        return _pyadchpp.CID_toHash(self)

    def data(self):
        """data(CID self) -> std::string"""
        return _pyadchpp.CID_data(self)

    def __str__(self):
        """__str__(CID self) -> std::string"""
        return _pyadchpp.CID___str__(self)

    def isZero(self):
        """isZero(CID self) -> bool"""
        return _pyadchpp.CID_isZero(self)

    def generate():
        """generate() -> CID"""
        return _pyadchpp.CID_generate()

    generate = staticmethod(generate)
    __swig_destroy__ = _pyadchpp.delete_CID
CID.__eq__ = new_instancemethod(_pyadchpp.CID___eq__,None,CID)
CID.__lt__ = new_instancemethod(_pyadchpp.CID___lt__,None,CID)
CID.toBase32 = new_instancemethod(_pyadchpp.CID_toBase32,None,CID)
CID.toHash = new_instancemethod(_pyadchpp.CID_toHash,None,CID)
CID.data = new_instancemethod(_pyadchpp.CID_data,None,CID)
CID.__str__ = new_instancemethod(_pyadchpp.CID___str__,None,CID)
CID.isZero = new_instancemethod(_pyadchpp.CID_isZero,None,CID)
CID_swigregister = _pyadchpp.CID_swigregister
CID_swigregister(CID)

def CID_generate():
  """CID_generate() -> CID"""
  return _pyadchpp.CID_generate()

class ParseException(Exception):
    """Proxy of C++ adchpp::ParseException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ParseException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ParseException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(adchpp::ParseException self) -> ParseException
        __init__(adchpp::ParseException self, std::string const & arg2) -> ParseException
        """
        _pyadchpp.ParseException_swiginit(self,_pyadchpp.new_ParseException(*args))
    __swig_destroy__ = _pyadchpp.delete_ParseException
ParseException_swigregister = _pyadchpp.ParseException_swigregister
ParseException_swigregister(ParseException)

class AdcCommand(object):
    """Proxy of C++ adchpp::AdcCommand class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    ERROR_GENERIC = _pyadchpp.AdcCommand_ERROR_GENERIC
    ERROR_HUB_GENERIC = _pyadchpp.AdcCommand_ERROR_HUB_GENERIC
    ERROR_HUB_FULL = _pyadchpp.AdcCommand_ERROR_HUB_FULL
    ERROR_HUB_DISABLED = _pyadchpp.AdcCommand_ERROR_HUB_DISABLED
    ERROR_LOGIN_GENERIC = _pyadchpp.AdcCommand_ERROR_LOGIN_GENERIC
    ERROR_NICK_INVALID = _pyadchpp.AdcCommand_ERROR_NICK_INVALID
    ERROR_NICK_TAKEN = _pyadchpp.AdcCommand_ERROR_NICK_TAKEN
    ERROR_BAD_PASSWORD = _pyadchpp.AdcCommand_ERROR_BAD_PASSWORD
    ERROR_CID_TAKEN = _pyadchpp.AdcCommand_ERROR_CID_TAKEN
    ERROR_COMMAND_ACCESS = _pyadchpp.AdcCommand_ERROR_COMMAND_ACCESS
    ERROR_REGGED_ONLY = _pyadchpp.AdcCommand_ERROR_REGGED_ONLY
    ERROR_INVALID_PID = _pyadchpp.AdcCommand_ERROR_INVALID_PID
    ERROR_BANNED_GENERIC = _pyadchpp.AdcCommand_ERROR_BANNED_GENERIC
    ERROR_PERM_BANNED = _pyadchpp.AdcCommand_ERROR_PERM_BANNED
    ERROR_TEMP_BANNED = _pyadchpp.AdcCommand_ERROR_TEMP_BANNED
    ERROR_PROTOCOL_GENERIC = _pyadchpp.AdcCommand_ERROR_PROTOCOL_GENERIC
    ERROR_PROTOCOL_UNSUPPORTED = _pyadchpp.AdcCommand_ERROR_PROTOCOL_UNSUPPORTED
    ERROR_INF_MISSING = _pyadchpp.AdcCommand_ERROR_INF_MISSING
    ERROR_BAD_STATE = _pyadchpp.AdcCommand_ERROR_BAD_STATE
    ERROR_FEATURE_MISSING = _pyadchpp.AdcCommand_ERROR_FEATURE_MISSING
    ERROR_BAD_IP = _pyadchpp.AdcCommand_ERROR_BAD_IP
    ERROR_TRANSFER_GENERIC = _pyadchpp.AdcCommand_ERROR_TRANSFER_GENERIC
    ERROR_FILE_NOT_AVAILABLE = _pyadchpp.AdcCommand_ERROR_FILE_NOT_AVAILABLE
    ERROR_FILE_PART_NOT_AVAILABLE = _pyadchpp.AdcCommand_ERROR_FILE_PART_NOT_AVAILABLE
    ERROR_SLOTS_FULL = _pyadchpp.AdcCommand_ERROR_SLOTS_FULL
    SEV_SUCCESS = _pyadchpp.AdcCommand_SEV_SUCCESS
    SEV_RECOVERABLE = _pyadchpp.AdcCommand_SEV_RECOVERABLE
    SEV_FATAL = _pyadchpp.AdcCommand_SEV_FATAL
    PRIORITY_NORMAL = _pyadchpp.AdcCommand_PRIORITY_NORMAL
    PRIORITY_LOW = _pyadchpp.AdcCommand_PRIORITY_LOW
    PRIORITY_IGNORE = _pyadchpp.AdcCommand_PRIORITY_IGNORE
    TYPE_BROADCAST = _pyadchpp.AdcCommand_TYPE_BROADCAST
    TYPE_CLIENT = _pyadchpp.AdcCommand_TYPE_CLIENT
    TYPE_DIRECT = _pyadchpp.AdcCommand_TYPE_DIRECT
    TYPE_ECHO = _pyadchpp.AdcCommand_TYPE_ECHO
    TYPE_FEATURE = _pyadchpp.AdcCommand_TYPE_FEATURE
    TYPE_INFO = _pyadchpp.AdcCommand_TYPE_INFO
    TYPE_HUB = _pyadchpp.AdcCommand_TYPE_HUB
    TYPE_UDP = _pyadchpp.AdcCommand_TYPE_UDP
    CMD_SUP = _pyadchpp.AdcCommand_CMD_SUP
    CMD_STA = _pyadchpp.AdcCommand_CMD_STA
    CMD_INF = _pyadchpp.AdcCommand_CMD_INF
    CMD_MSG = _pyadchpp.AdcCommand_CMD_MSG
    CMD_SCH = _pyadchpp.AdcCommand_CMD_SCH
    CMD_RES = _pyadchpp.AdcCommand_CMD_RES
    CMD_CTM = _pyadchpp.AdcCommand_CMD_CTM
    CMD_RCM = _pyadchpp.AdcCommand_CMD_RCM
    CMD_GPA = _pyadchpp.AdcCommand_CMD_GPA
    CMD_PAS = _pyadchpp.AdcCommand_CMD_PAS
    CMD_QUI = _pyadchpp.AdcCommand_CMD_QUI
    CMD_GET = _pyadchpp.AdcCommand_CMD_GET
    CMD_GFI = _pyadchpp.AdcCommand_CMD_GFI
    CMD_SND = _pyadchpp.AdcCommand_CMD_SND
    CMD_SID = _pyadchpp.AdcCommand_CMD_SID
    CMD_CMD = _pyadchpp.AdcCommand_CMD_CMD
    CMD_NAT = _pyadchpp.AdcCommand_CMD_NAT
    CMD_RNT = _pyadchpp.AdcCommand_CMD_RNT
    def __init__(self, *args): 
        """
        __init__(adchpp::AdcCommand self) -> AdcCommand
        __init__(adchpp::AdcCommand self, adchpp::AdcCommand::Severity sev, adchpp::AdcCommand::Error err, std::string const & desc, 
            char aType) -> AdcCommand
        __init__(adchpp::AdcCommand self, uint32_t cmd, char aType, uint32_t aFrom) -> AdcCommand
        __init__(adchpp::AdcCommand self, std::string const & aLine) -> AdcCommand
        __init__(adchpp::AdcCommand self, adchpp::BufferPtr const & buffer_) -> AdcCommand
        """
        _pyadchpp.AdcCommand_swiginit(self,_pyadchpp.new_AdcCommand(*args))
    def toSID(*args):
        """toSID(std::string const & aSID) -> uint32_t"""
        return _pyadchpp.AdcCommand_toSID(*args)

    toSID = staticmethod(toSID)
    def fromSID(*args):
        """fromSID(uint32_t const aSID) -> std::string"""
        return _pyadchpp.AdcCommand_fromSID(*args)

    fromSID = staticmethod(fromSID)
    def appendSID(*args):
        """appendSID(std::string & str, uint32_t aSID)"""
        return _pyadchpp.AdcCommand_appendSID(*args)

    appendSID = staticmethod(appendSID)
    def toField(*args):
        """toField(char const * x) -> uint16_t"""
        return _pyadchpp.AdcCommand_toField(*args)

    toField = staticmethod(toField)
    def fromField(*args):
        """fromField(uint16_t const aField) -> std::string"""
        return _pyadchpp.AdcCommand_fromField(*args)

    fromField = staticmethod(fromField)
    def toFourCC(*args):
        """toFourCC(char const * x) -> uint32_t"""
        return _pyadchpp.AdcCommand_toFourCC(*args)

    toFourCC = staticmethod(toFourCC)
    def fromFourCC(*args):
        """fromFourCC(uint32_t x) -> std::string"""
        return _pyadchpp.AdcCommand_fromFourCC(*args)

    fromFourCC = staticmethod(fromFourCC)
    def parse(self, *args):
        """parse(AdcCommand self, std::string const & aLine)"""
        return _pyadchpp.AdcCommand_parse(self, *args)

    def getCommand(self):
        """getCommand(AdcCommand self) -> uint32_t"""
        return _pyadchpp.AdcCommand_getCommand(self)

    def getType(self):
        """getType(AdcCommand self) -> char"""
        return _pyadchpp.AdcCommand_getType(self)

    def getFourCC(self):
        """getFourCC(AdcCommand self) -> std::string"""
        return _pyadchpp.AdcCommand_getFourCC(self)

    def getParameters(self):
        """getParameters(AdcCommand self) -> TStringList"""
        return _pyadchpp.AdcCommand_getParameters(self)

    def toString(self):
        """toString(AdcCommand self) -> std::string"""
        return _pyadchpp.AdcCommand_toString(self)

    def resetBuffer(self):
        """resetBuffer(AdcCommand self)"""
        return _pyadchpp.AdcCommand_resetBuffer(self)

    def addParam(self, *args):
        """
        addParam(AdcCommand self, std::string const & name, std::string const & value) -> AdcCommand
        addParam(AdcCommand self, std::string const & str) -> AdcCommand
        """
        return _pyadchpp.AdcCommand_addParam(self, *args)

    def getFeatures(self):
        """getFeatures(AdcCommand self) -> std::string const &"""
        return _pyadchpp.AdcCommand_getFeatures(self)

    def getBuffer(self):
        """getBuffer(AdcCommand self) -> adchpp::BufferPtr const &"""
        return _pyadchpp.AdcCommand_getBuffer(self)

    def getParam(self, *args):
        """
        getParam(AdcCommand self, size_t n) -> std::string const
        getParam(AdcCommand self, char const * name, size_t start) -> bool
        """
        return _pyadchpp.AdcCommand_getParam(self, *args)

    def delParam(self, *args):
        """delParam(AdcCommand self, char const * name, size_t start) -> bool"""
        return _pyadchpp.AdcCommand_delParam(self, *args)

    def hasFlag(self, *args):
        """hasFlag(AdcCommand self, char const * name, size_t start) -> bool"""
        return _pyadchpp.AdcCommand_hasFlag(self, *args)

    def __eq__(self, *args):
        """__eq__(AdcCommand self, uint32_t aCmd) -> bool"""
        return _pyadchpp.AdcCommand___eq__(self, *args)

    def escape(*args):
        """escape(std::string const & s, std::string & out)"""
        return _pyadchpp.AdcCommand_escape(*args)

    escape = staticmethod(escape)
    def getTo(self):
        """getTo(AdcCommand self) -> uint32_t"""
        return _pyadchpp.AdcCommand_getTo(self)

    def setTo(self, *args):
        """setTo(AdcCommand self, uint32_t aTo)"""
        return _pyadchpp.AdcCommand_setTo(self, *args)

    def getFrom(self):
        """getFrom(AdcCommand self) -> uint32_t"""
        return _pyadchpp.AdcCommand_getFrom(self)

    def setFrom(self, *args):
        """setFrom(AdcCommand self, uint32_t aFrom)"""
        return _pyadchpp.AdcCommand_setFrom(self, *args)

    def getPriority(self):
        """getPriority(AdcCommand self) -> adchpp::AdcCommand::Priority"""
        return _pyadchpp.AdcCommand_getPriority(self)

    def setPriority(self, *args):
        """setPriority(AdcCommand self, adchpp::AdcCommand::Priority priority_)"""
        return _pyadchpp.AdcCommand_setPriority(self, *args)

    def getCommandString(self):
        """getCommandString(AdcCommand self) -> std::string"""
        return _pyadchpp.AdcCommand_getCommandString(self)

    def toCMD(*args):
        """
        toCMD(uint8_t a, uint8_t b, uint8_t c) -> uint32_t
        toCMD(std::string const & cmd) -> uint32_t
        """
        return _pyadchpp.AdcCommand_toCMD(*args)

    toCMD = staticmethod(toCMD)
    type = property(getType) 
    parameters = property(getParameters) 
    features = property(getFeatures) 
    source = property(getFrom,setFrom) 
    to = property(getTo,setTo) 
    priority = property(getPriority,setPriority) 
    command = property(getCommandString) 
    __swig_destroy__ = _pyadchpp.delete_AdcCommand
AdcCommand.parse = new_instancemethod(_pyadchpp.AdcCommand_parse,None,AdcCommand)
AdcCommand.getCommand = new_instancemethod(_pyadchpp.AdcCommand_getCommand,None,AdcCommand)
AdcCommand.getType = new_instancemethod(_pyadchpp.AdcCommand_getType,None,AdcCommand)
AdcCommand.getFourCC = new_instancemethod(_pyadchpp.AdcCommand_getFourCC,None,AdcCommand)
AdcCommand.getParameters = new_instancemethod(_pyadchpp.AdcCommand_getParameters,None,AdcCommand)
AdcCommand.toString = new_instancemethod(_pyadchpp.AdcCommand_toString,None,AdcCommand)
AdcCommand.resetBuffer = new_instancemethod(_pyadchpp.AdcCommand_resetBuffer,None,AdcCommand)
AdcCommand.addParam = new_instancemethod(_pyadchpp.AdcCommand_addParam,None,AdcCommand)
AdcCommand.getFeatures = new_instancemethod(_pyadchpp.AdcCommand_getFeatures,None,AdcCommand)
AdcCommand.getBuffer = new_instancemethod(_pyadchpp.AdcCommand_getBuffer,None,AdcCommand)
AdcCommand.getParam = new_instancemethod(_pyadchpp.AdcCommand_getParam,None,AdcCommand)
AdcCommand.delParam = new_instancemethod(_pyadchpp.AdcCommand_delParam,None,AdcCommand)
AdcCommand.hasFlag = new_instancemethod(_pyadchpp.AdcCommand_hasFlag,None,AdcCommand)
AdcCommand.__eq__ = new_instancemethod(_pyadchpp.AdcCommand___eq__,None,AdcCommand)
AdcCommand.getTo = new_instancemethod(_pyadchpp.AdcCommand_getTo,None,AdcCommand)
AdcCommand.setTo = new_instancemethod(_pyadchpp.AdcCommand_setTo,None,AdcCommand)
AdcCommand.getFrom = new_instancemethod(_pyadchpp.AdcCommand_getFrom,None,AdcCommand)
AdcCommand.setFrom = new_instancemethod(_pyadchpp.AdcCommand_setFrom,None,AdcCommand)
AdcCommand.getPriority = new_instancemethod(_pyadchpp.AdcCommand_getPriority,None,AdcCommand)
AdcCommand.setPriority = new_instancemethod(_pyadchpp.AdcCommand_setPriority,None,AdcCommand)
AdcCommand.getCommandString = new_instancemethod(_pyadchpp.AdcCommand_getCommandString,None,AdcCommand)
AdcCommand_swigregister = _pyadchpp.AdcCommand_swigregister
AdcCommand_swigregister(AdcCommand)
AdcCommand.HUB_SID = _pyadchpp.cvar.AdcCommand_HUB_SID
AdcCommand.INVALID_SID = _pyadchpp.cvar.AdcCommand_INVALID_SID

def AdcCommand_toSID(*args):
  """AdcCommand_toSID(std::string const & aSID) -> uint32_t"""
  return _pyadchpp.AdcCommand_toSID(*args)

def AdcCommand_fromSID(*args):
  """AdcCommand_fromSID(uint32_t const aSID) -> std::string"""
  return _pyadchpp.AdcCommand_fromSID(*args)

def AdcCommand_appendSID(*args):
  """AdcCommand_appendSID(std::string & str, uint32_t aSID)"""
  return _pyadchpp.AdcCommand_appendSID(*args)

def AdcCommand_toField(*args):
  """AdcCommand_toField(char const * x) -> uint16_t"""
  return _pyadchpp.AdcCommand_toField(*args)

def AdcCommand_fromField(*args):
  """AdcCommand_fromField(uint16_t const aField) -> std::string"""
  return _pyadchpp.AdcCommand_fromField(*args)

def AdcCommand_toFourCC(*args):
  """AdcCommand_toFourCC(char const * x) -> uint32_t"""
  return _pyadchpp.AdcCommand_toFourCC(*args)

def AdcCommand_fromFourCC(*args):
  """AdcCommand_fromFourCC(uint32_t x) -> std::string"""
  return _pyadchpp.AdcCommand_fromFourCC(*args)

def AdcCommand_escape(*args):
  """AdcCommand_escape(std::string const & s, std::string & out)"""
  return _pyadchpp.AdcCommand_escape(*args)

def AdcCommand_toCMD(*args):
  """
    toCMD(uint8_t a, uint8_t b, uint8_t c) -> uint32_t
    AdcCommand_toCMD(std::string const & cmd) -> uint32_t
    """
  return _pyadchpp.AdcCommand_toCMD(*args)

class Entity(object):
    """Proxy of C++ adchpp::Entity class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    STATE_PROTOCOL = _pyadchpp.Entity_STATE_PROTOCOL
    STATE_IDENTIFY = _pyadchpp.Entity_STATE_IDENTIFY
    STATE_VERIFY = _pyadchpp.Entity_STATE_VERIFY
    STATE_NORMAL = _pyadchpp.Entity_STATE_NORMAL
    STATE_DATA = _pyadchpp.Entity_STATE_DATA
    FLAG_BOT = _pyadchpp.Entity_FLAG_BOT
    FLAG_REGISTERED = _pyadchpp.Entity_FLAG_REGISTERED
    FLAG_OP = _pyadchpp.Entity_FLAG_OP
    FLAG_SU = _pyadchpp.Entity_FLAG_SU
    FLAG_OWNER = _pyadchpp.Entity_FLAG_OWNER
    FLAG_HUB = _pyadchpp.Entity_FLAG_HUB
    FLAG_HIDDEN = _pyadchpp.Entity_FLAG_HIDDEN
    MASK_CLIENT_TYPE = _pyadchpp.Entity_MASK_CLIENT_TYPE
    FLAG_PASSWORD = _pyadchpp.Entity_FLAG_PASSWORD
    FLAG_EXT_AWAY = _pyadchpp.Entity_FLAG_EXT_AWAY
    FLAG_OK_IP = _pyadchpp.Entity_FLAG_OK_IP
    FLAG_GHOST = _pyadchpp.Entity_FLAG_GHOST
    def send(self, *args):
        """
        send(Entity self, AdcCommand cmd)
        send(Entity self, adchpp::BufferPtr const & cmd)
        """
        return _pyadchpp.Entity_send(self, *args)

    def inject(self, *args):
        """inject(Entity self, AdcCommand cmd)"""
        return _pyadchpp.Entity_inject(self, *args)

    def getField(self, *args):
        """getField(Entity self, char const * name) -> std::string const &"""
        return _pyadchpp.Entity_getField(self, *args)

    def hasField(self, *args):
        """hasField(Entity self, char const * name) -> bool"""
        return _pyadchpp.Entity_hasField(self, *args)

    def setField(self, *args):
        """setField(Entity self, char const * name, std::string const & value)"""
        return _pyadchpp.Entity_setField(self, *args)

    def getAllFields(self, *args):
        """getAllFields(Entity self, AdcCommand cmd) -> bool"""
        return _pyadchpp.Entity_getAllFields(self, *args)

    def getINF(self):
        """getINF(Entity self) -> adchpp::BufferPtr const &"""
        return _pyadchpp.Entity_getINF(self)

    def addSupports(self, *args):
        """addSupports(Entity self, uint32_t feature) -> bool"""
        return _pyadchpp.Entity_addSupports(self, *args)

    def getSupportList(self):
        """getSupportList(Entity self) -> TStringList"""
        return _pyadchpp.Entity_getSupportList(self)

    def hasSupport(self, *args):
        """hasSupport(Entity self, uint32_t feature) -> bool"""
        return _pyadchpp.Entity_hasSupport(self, *args)

    def removeSupports(self, *args):
        """removeSupports(Entity self, uint32_t feature) -> bool"""
        return _pyadchpp.Entity_removeSupports(self, *args)

    def getSUP(self):
        """getSUP(Entity self) -> adchpp::BufferPtr const &"""
        return _pyadchpp.Entity_getSUP(self)

    def getSID(self):
        """getSID(Entity self) -> uint32_t"""
        return _pyadchpp.Entity_getSID(self)

    def isFiltered(self, *args):
        """isFiltered(Entity self, std::string const & features) -> bool"""
        return _pyadchpp.Entity_isFiltered(self, *args)

    def updateFields(self, *args):
        """updateFields(Entity self, AdcCommand cmd)"""
        return _pyadchpp.Entity_updateFields(self, *args)

    def updateSupports(self, *args):
        """updateSupports(Entity self, AdcCommand cmd)"""
        return _pyadchpp.Entity_updateSupports(self, *args)

    def getCID(self):
        """getCID(Entity self) -> CID"""
        return _pyadchpp.Entity_getCID(self)

    def setCID(self, *args):
        """setCID(Entity self, CID cid_)"""
        return _pyadchpp.Entity_setCID(self, *args)

    def getState(self):
        """getState(Entity self) -> adchpp::Entity::State"""
        return _pyadchpp.Entity_getState(self)

    def setState(self, *args):
        """setState(Entity self, adchpp::Entity::State state_)"""
        return _pyadchpp.Entity_setState(self, *args)

    def isSet(self, *args):
        """isSet(Entity self, size_t aFlag) -> bool"""
        return _pyadchpp.Entity_isSet(self, *args)

    def isAnySet(self, *args):
        """isAnySet(Entity self, size_t aFlag) -> bool"""
        return _pyadchpp.Entity_isAnySet(self, *args)

    def setFlag(self, *args):
        """setFlag(Entity self, size_t aFlag)"""
        return _pyadchpp.Entity_setFlag(self, *args)

    def unsetFlag(self, *args):
        """unsetFlag(Entity self, size_t aFlag)"""
        return _pyadchpp.Entity_unsetFlag(self, *args)

    def asClient(self):
        """asClient(Entity self) -> Client"""
        return _pyadchpp.Entity_asClient(self)

    def asHub(self):
        """asHub(Entity self) -> Hub *"""
        return _pyadchpp.Entity_asHub(self)

    def asBot(self):
        """asBot(Entity self) -> Bot"""
        return _pyadchpp.Entity_asBot(self)

    def setPluginData(self, *args):
        """
        setPluginData(Entity self, PluginDataHandle const & handle, PyObject * data)
        setPluginData(Entity self, PyObject * data)
        """
        return _pyadchpp.Entity_setPluginData(self, *args)

    def getPluginData(self, *args):
        """
        getPluginData(Entity self, PluginDataHandle const & handle) -> PyObject
        getPluginData(Entity self) -> PyObject *
        """
        return _pyadchpp.Entity_getPluginData(self, *args)

    pluginData = property(getPluginData,setPluginData) 
    SID = property(getSID) 
    state = property(getState,setState) 
    CID = property(getCID) 
    supportList = property(getSupportList) 
Entity.send = new_instancemethod(_pyadchpp.Entity_send,None,Entity)
Entity.inject = new_instancemethod(_pyadchpp.Entity_inject,None,Entity)
Entity.getField = new_instancemethod(_pyadchpp.Entity_getField,None,Entity)
Entity.hasField = new_instancemethod(_pyadchpp.Entity_hasField,None,Entity)
Entity.setField = new_instancemethod(_pyadchpp.Entity_setField,None,Entity)
Entity.getAllFields = new_instancemethod(_pyadchpp.Entity_getAllFields,None,Entity)
Entity.getINF = new_instancemethod(_pyadchpp.Entity_getINF,None,Entity)
Entity.addSupports = new_instancemethod(_pyadchpp.Entity_addSupports,None,Entity)
Entity.getSupportList = new_instancemethod(_pyadchpp.Entity_getSupportList,None,Entity)
Entity.hasSupport = new_instancemethod(_pyadchpp.Entity_hasSupport,None,Entity)
Entity.removeSupports = new_instancemethod(_pyadchpp.Entity_removeSupports,None,Entity)
Entity.getSUP = new_instancemethod(_pyadchpp.Entity_getSUP,None,Entity)
Entity.getSID = new_instancemethod(_pyadchpp.Entity_getSID,None,Entity)
Entity.isFiltered = new_instancemethod(_pyadchpp.Entity_isFiltered,None,Entity)
Entity.updateFields = new_instancemethod(_pyadchpp.Entity_updateFields,None,Entity)
Entity.updateSupports = new_instancemethod(_pyadchpp.Entity_updateSupports,None,Entity)
Entity.getCID = new_instancemethod(_pyadchpp.Entity_getCID,None,Entity)
Entity.setCID = new_instancemethod(_pyadchpp.Entity_setCID,None,Entity)
Entity.getState = new_instancemethod(_pyadchpp.Entity_getState,None,Entity)
Entity.setState = new_instancemethod(_pyadchpp.Entity_setState,None,Entity)
Entity.isSet = new_instancemethod(_pyadchpp.Entity_isSet,None,Entity)
Entity.isAnySet = new_instancemethod(_pyadchpp.Entity_isAnySet,None,Entity)
Entity.setFlag = new_instancemethod(_pyadchpp.Entity_setFlag,None,Entity)
Entity.unsetFlag = new_instancemethod(_pyadchpp.Entity_unsetFlag,None,Entity)
Entity.asClient = new_instancemethod(_pyadchpp.Entity_asClient,None,Entity)
Entity.asHub = new_instancemethod(_pyadchpp.Entity_asHub,None,Entity)
Entity.asBot = new_instancemethod(_pyadchpp.Entity_asBot,None,Entity)
Entity.setPluginData = new_instancemethod(_pyadchpp.Entity_setPluginData,None,Entity)
Entity.getPluginData = new_instancemethod(_pyadchpp.Entity_getPluginData,None,Entity)
Entity_swigregister = _pyadchpp.Entity_swigregister
Entity_swigregister(Entity)

class Client(Entity):
    """Proxy of C++ adchpp::Client class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def send(self, *args):
        """
        send(Client self, AdcCommand cmd)
        send(Client self, adchpp::BufferPtr const & cmd)
        send(Client self, adchpp::BufferPtr const & command)
        """
        return _pyadchpp.Client_send(self, *args)

    def getQueuedBytes(self):
        """getQueuedBytes(Client self) -> size_t"""
        return _pyadchpp.Client_getQueuedBytes(self)

    def getIp(self):
        """getIp(Client self) -> std::string const &"""
        return _pyadchpp.Client_getIp(self)

    def setDataMode(self, *args):
        """setDataMode(Client self, adchpp::Client::DataFunction const & handler, int64_t aBytes)"""
        return _pyadchpp.Client_setDataMode(self, *args)

    def disconnect(self, *args):
        """
        disconnect(Client self, int reason)
        disconnect(Client self, int reason, std::string const & info)
        """
        return _pyadchpp.Client_disconnect(self, *args)

    ip = property(getIp) 
Client.send = new_instancemethod(_pyadchpp.Client_send,None,Client)
Client.getQueuedBytes = new_instancemethod(_pyadchpp.Client_getQueuedBytes,None,Client)
Client.getIp = new_instancemethod(_pyadchpp.Client_getIp,None,Client)
Client.setDataMode = new_instancemethod(_pyadchpp.Client_setDataMode,None,Client)
Client.disconnect = new_instancemethod(_pyadchpp.Client_disconnect,None,Client)
Client_swigregister = _pyadchpp.Client_swigregister
Client_swigregister(Client)

class Bot(Entity):
    """Proxy of C++ adchpp::Bot class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def send(self, *args):
        """
        send(Bot self, AdcCommand cmd)
        send(Bot self, adchpp::BufferPtr const & cmd)
        send(Bot self, adchpp::BufferPtr const & cmd)
        """
        return _pyadchpp.Bot_send(self, *args)

    def disconnect(self, *args):
        """
        disconnect(Bot self, int reason)
        disconnect(Bot self, int reason, std::string const & info)
        """
        return _pyadchpp.Bot_disconnect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_Bot
Bot.send = new_instancemethod(_pyadchpp.Bot_send,None,Bot)
Bot.disconnect = new_instancemethod(_pyadchpp.Bot_disconnect,None,Bot)
Bot_swigregister = _pyadchpp.Bot_swigregister
Bot_swigregister(Bot)

class Hub(Entity):
    """Proxy of C++ adchpp::Hub class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_Hub
Hub_swigregister = _pyadchpp.Hub_swigregister
Hub_swigregister(Hub)

class SignalE(object):
    """Proxy of C++ adchpp::Signal<(f(r.adchpp::Entity).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalE self, std::function< void (adchpp::Entity &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalE_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalE
SignalE.connect = new_instancemethod(_pyadchpp.SignalE_connect,None,SignalE)
SignalE_swigregister = _pyadchpp.SignalE_swigregister
SignalE_swigregister(SignalE)

class SignalTraitsE(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.adchpp::Entity).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsE
SignalTraitsE_swigregister = _pyadchpp.SignalTraitsE_swigregister
SignalTraitsE_swigregister(SignalTraitsE)

class SignalEAB(object):
    """Proxy of C++ adchpp::Signal<(f(r.adchpp::Entity,r.adchpp::AdcCommand,r.bool).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalEAB self, std::function< void (adchpp::Entity &,adchpp::AdcCommand &,bool &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalEAB_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalEAB
SignalEAB.connect = new_instancemethod(_pyadchpp.SignalEAB_connect,None,SignalEAB)
SignalEAB_swigregister = _pyadchpp.SignalEAB_swigregister
SignalEAB_swigregister(SignalEAB)

class SignalTraitsEAB(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.adchpp::Entity,r.adchpp::AdcCommand,r.bool).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsEAB
SignalTraitsEAB_swigregister = _pyadchpp.SignalTraitsEAB_swigregister
SignalTraitsEAB_swigregister(SignalTraitsEAB)

class SignalES(object):
    """Proxy of C++ adchpp::Signal<(f(r.adchpp::Entity,r.q(const).std::string).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalES self, std::function< void (adchpp::Entity &,std::string const &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalES_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalES
SignalES.connect = new_instancemethod(_pyadchpp.SignalES_connect,None,SignalES)
SignalES_swigregister = _pyadchpp.SignalES_swigregister
SignalES_swigregister(SignalES)

class SignalTraitsES(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.adchpp::Entity,r.q(const).std::string).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsES
SignalTraitsES_swigregister = _pyadchpp.SignalTraitsES_swigregister
SignalTraitsES_swigregister(SignalTraitsES)

class SignalEcAB(object):
    """Proxy of C++ adchpp::Signal<(f(r.adchpp::Entity,r.q(const).adchpp::AdcCommand,r.bool).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalEcAB self, std::function< void (adchpp::Entity &,adchpp::AdcCommand const &,bool &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalEcAB_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalEcAB
SignalEcAB.connect = new_instancemethod(_pyadchpp.SignalEcAB_connect,None,SignalEcAB)
SignalEcAB_swigregister = _pyadchpp.SignalEcAB_swigregister
SignalEcAB_swigregister(SignalEcAB)

class SignalTraitsEcAB(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.adchpp::Entity,r.q(const).adchpp::AdcCommand,r.bool).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsEcAB
SignalTraitsEcAB_swigregister = _pyadchpp.SignalTraitsEcAB_swigregister
SignalTraitsEcAB_swigregister(SignalTraitsEcAB)

class SignalEI(object):
    """Proxy of C++ adchpp::Signal<(f(r.adchpp::Entity,int).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalEI self, std::function< void (adchpp::Entity &,int) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalEI_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalEI
SignalEI.connect = new_instancemethod(_pyadchpp.SignalEI_connect,None,SignalEI)
SignalEI_swigregister = _pyadchpp.SignalEI_swigregister
SignalEI_swigregister(SignalEI)

class SignalTraitsEI(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.adchpp::Entity,int).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsEI
SignalTraitsEI_swigregister = _pyadchpp.SignalTraitsEI_swigregister
SignalTraitsEI_swigregister(SignalTraitsEI)

class SignalERS(object):
    """Proxy of C++ adchpp::Signal<(f(r.adchpp::Entity,DCReason,r.q(const).std::string).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalERS self, std::function< void (adchpp::Entity &,DCReason,std::string const &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalERS_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalERS
SignalERS.connect = new_instancemethod(_pyadchpp.SignalERS_connect,None,SignalERS)
SignalERS_swigregister = _pyadchpp.SignalERS_swigregister
SignalERS_swigregister(SignalERS)

class SignalTraitsERS(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.adchpp::Entity,DCReason,r.q(const).std::string).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsERS
SignalTraitsERS_swigregister = _pyadchpp.SignalTraitsERS_swigregister
SignalTraitsERS_swigregister(SignalTraitsERS)

class SignalESB(object):
    """Proxy of C++ adchpp::Signal<(f(r.adchpp::Entity,r.q(const).adchpp::StringList,r.bool).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalESB self, std::function< void (adchpp::Entity &,adchpp::StringList const &,bool &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalESB_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalESB
SignalESB.connect = new_instancemethod(_pyadchpp.SignalESB_connect,None,SignalESB)
SignalESB_swigregister = _pyadchpp.SignalESB_swigregister
SignalESB_swigregister(SignalESB)

class SignalTraitsESB(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.adchpp::Entity,r.q(const).adchpp::StringList,r.bool).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsESB
SignalTraitsESB_swigregister = _pyadchpp.SignalTraitsESB_swigregister
SignalTraitsESB_swigregister(SignalTraitsESB)

class SignalS(object):
    """Proxy of C++ adchpp::Signal<(f(r.q(const).SimpleXML).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalS self, std::function< void (SimpleXML const &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalS_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalS
SignalS.connect = new_instancemethod(_pyadchpp.SignalS_connect,None,SignalS)
SignalS_swigregister = _pyadchpp.SignalS_swigregister
SignalS_swigregister(SignalS)

class SignalTraitsS(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.q(const).SimpleXML).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsS
SignalTraitsS_swigregister = _pyadchpp.SignalTraitsS_swigregister
SignalTraitsS_swigregister(SignalTraitsS)

class SignalSt(object):
    """Proxy of C++ adchpp::Signal<(f(r.q(const).std::string).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def connect(self, *args):
        """connect(SignalSt self, std::function< void (std::string const &) > f) -> TManagedConnectionPtr"""
        return _pyadchpp.SignalSt_connect(self, *args)

    __swig_destroy__ = _pyadchpp.delete_SignalSt
SignalSt.connect = new_instancemethod(_pyadchpp.SignalSt_connect,None,SignalSt)
SignalSt_swigregister = _pyadchpp.SignalSt_swigregister
SignalSt_swigregister(SignalSt)

class SignalTraitsSt(object):
    """Proxy of C++ adchpp::SignalTraits<(f(r.q(const).std::string).void)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_SignalTraitsSt
SignalTraitsSt_swigregister = _pyadchpp.SignalTraitsSt_swigregister
SignalTraitsSt_swigregister(SignalTraitsSt)

class LogManager(object):
    """Proxy of C++ adchpp::LogManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def log(self, *args):
        """log(LogManager self, std::string const & area, std::string const & msg)"""
        return _pyadchpp.LogManager_log(self, *args)

    def setLogFile(self, *args):
        """setLogFile(LogManager self, std::string const & fileName)"""
        return _pyadchpp.LogManager_setLogFile(self, *args)

    def getLogFile(self):
        """getLogFile(LogManager self) -> std::string const &"""
        return _pyadchpp.LogManager_getLogFile(self)

    def setEnabled(self, *args):
        """setEnabled(LogManager self, bool enabled_)"""
        return _pyadchpp.LogManager_setEnabled(self, *args)

    def getEnabled(self):
        """getEnabled(LogManager self) -> bool"""
        return _pyadchpp.LogManager_getEnabled(self)

    def signalLog(self):
        """signalLog(LogManager self) -> SignalSt"""
        return _pyadchpp.LogManager_signalLog(self)

    logFile = property(getLogFile,setLogFile) 
    enabled = property(getEnabled,setEnabled) 
LogManager.log = new_instancemethod(_pyadchpp.LogManager_log,None,LogManager)
LogManager.setLogFile = new_instancemethod(_pyadchpp.LogManager_setLogFile,None,LogManager)
LogManager.getLogFile = new_instancemethod(_pyadchpp.LogManager_getLogFile,None,LogManager)
LogManager.setEnabled = new_instancemethod(_pyadchpp.LogManager_setEnabled,None,LogManager)
LogManager.getEnabled = new_instancemethod(_pyadchpp.LogManager_getEnabled,None,LogManager)
LogManager.signalLog = new_instancemethod(_pyadchpp.LogManager_signalLog,None,LogManager)
LogManager_swigregister = _pyadchpp.LogManager_swigregister
LogManager_swigregister(LogManager)

class ClientManager(object):
    """Proxy of C++ adchpp::ClientManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getEntity(self, *args):
        """getEntity(ClientManager self, uint32_t aSid) -> Entity"""
        return _pyadchpp.ClientManager_getEntity(self, *args)

    def createSimpleBot(self):
        """createSimpleBot(ClientManager self) -> Bot"""
        return _pyadchpp.ClientManager_createSimpleBot(self)

    def regBot(self, *args):
        """regBot(ClientManager self, Bot bot)"""
        return _pyadchpp.ClientManager_regBot(self, *args)

    def getEntities(self):
        """getEntities(ClientManager self) -> TEntityList"""
        return _pyadchpp.ClientManager_getEntities(self)

    def findByCID(self, *args):
        """findByCID(ClientManager self, CID cid) -> Entity"""
        return _pyadchpp.ClientManager_findByCID(self, *args)

    def findByNick(self, *args):
        """findByNick(ClientManager self, std::string const & nick) -> Entity"""
        return _pyadchpp.ClientManager_findByNick(self, *args)

    def send(self, *args):
        """send(ClientManager self, AdcCommand cmd)"""
        return _pyadchpp.ClientManager_send(self, *args)

    def sendToAll(self, *args):
        """sendToAll(ClientManager self, adchpp::BufferPtr const & buffer)"""
        return _pyadchpp.ClientManager_sendToAll(self, *args)

    def sendTo(self, *args):
        """sendTo(ClientManager self, adchpp::BufferPtr const & buffer, uint32_t to)"""
        return _pyadchpp.ClientManager_sendTo(self, *args)

    def enterIdentify(self, *args):
        """enterIdentify(ClientManager self, Entity c, bool sendData)"""
        return _pyadchpp.ClientManager_enterIdentify(self, *args)

    def enterVerify(self, *args):
        """enterVerify(ClientManager self, Entity c, bool sendData) -> TByteVector"""
        return _pyadchpp.ClientManager_enterVerify(self, *args)

    def enterNormal(self, *args):
        """enterNormal(ClientManager self, Entity c, bool sendData, bool sendOwnInf) -> bool"""
        return _pyadchpp.ClientManager_enterNormal(self, *args)

    def verifySUP(self, *args):
        """verifySUP(ClientManager self, Entity c, AdcCommand cmd) -> bool"""
        return _pyadchpp.ClientManager_verifySUP(self, *args)

    def verifyINF(self, *args):
        """verifyINF(ClientManager self, Entity c, AdcCommand cmd) -> bool"""
        return _pyadchpp.ClientManager_verifyINF(self, *args)

    def verifyNick(self, *args):
        """verifyNick(ClientManager self, Entity c, AdcCommand cmd) -> bool"""
        return _pyadchpp.ClientManager_verifyNick(self, *args)

    def verifyPassword(self, *args):
        """verifyPassword(ClientManager self, Entity c, std::string const & password, TByteVector salt, std::string const & suppliedHash) -> bool"""
        return _pyadchpp.ClientManager_verifyPassword(self, *args)

    def verifyHashedPassword(self, *args):
        """
        verifyHashedPassword(ClientManager self, Entity c, TByteVector hashedPassword, int64_t hashedPasswordLen, TByteVector salt, 
            std::string const & suppliedHash) -> bool
        """
        return _pyadchpp.ClientManager_verifyHashedPassword(self, *args)

    def verifyIp(self, *args):
        """verifyIp(ClientManager self, Client c, AdcCommand cmd, bool isHbriConn) -> bool"""
        return _pyadchpp.ClientManager_verifyIp(self, *args)

    def verifyCID(self, *args):
        """verifyCID(ClientManager self, Entity c, AdcCommand cmd) -> bool"""
        return _pyadchpp.ClientManager_verifyCID(self, *args)

    def verifyOverflow(self, *args):
        """verifyOverflow(ClientManager self, Entity c) -> bool"""
        return _pyadchpp.ClientManager_verifyOverflow(self, *args)

    def setState(self, *args):
        """setState(ClientManager self, Entity c, adchpp::Entity::State newState)"""
        return _pyadchpp.ClientManager_setState(self, *args)

    def getQueuedBytes(self):
        """getQueuedBytes(ClientManager self) -> size_t"""
        return _pyadchpp.ClientManager_getQueuedBytes(self)

    def signalConnected(self):
        """signalConnected(ClientManager self) -> SignalE"""
        return _pyadchpp.ClientManager_signalConnected(self)

    def signalReady(self):
        """signalReady(ClientManager self) -> SignalE"""
        return _pyadchpp.ClientManager_signalReady(self)

    def signalReceive(self):
        """signalReceive(ClientManager self) -> SignalEAB"""
        return _pyadchpp.ClientManager_signalReceive(self)

    def signalBadLine(self):
        """signalBadLine(ClientManager self) -> SignalES"""
        return _pyadchpp.ClientManager_signalBadLine(self)

    def signalSend(self):
        """signalSend(ClientManager self) -> SignalEcAB"""
        return _pyadchpp.ClientManager_signalSend(self)

    def signalState(self):
        """signalState(ClientManager self) -> SignalEI"""
        return _pyadchpp.ClientManager_signalState(self)

    def signalDisconnected(self):
        """signalDisconnected(ClientManager self) -> SignalERS"""
        return _pyadchpp.ClientManager_signalDisconnected(self)

    def setMaxCommandSize(self, *args):
        """setMaxCommandSize(ClientManager self, size_t newSize)"""
        return _pyadchpp.ClientManager_setMaxCommandSize(self, *args)

    def getMaxCommandSize(self):
        """getMaxCommandSize(ClientManager self) -> size_t"""
        return _pyadchpp.ClientManager_getMaxCommandSize(self)

    def setLogTimeout(self, *args):
        """setLogTimeout(ClientManager self, size_t millis)"""
        return _pyadchpp.ClientManager_setLogTimeout(self, *args)

    def getLogTimeout(self):
        """getLogTimeout(ClientManager self) -> size_t"""
        return _pyadchpp.ClientManager_getLogTimeout(self)

    def createBot(self, *args):
        """
        createBot(ClientManager self, adchpp::Bot::SendHandler handler) -> Bot
        createBot(ClientManager self, PyObject * obj) -> Bot
        """
        return _pyadchpp.ClientManager_createBot(self, *args)

ClientManager.getEntity = new_instancemethod(_pyadchpp.ClientManager_getEntity,None,ClientManager)
ClientManager.createSimpleBot = new_instancemethod(_pyadchpp.ClientManager_createSimpleBot,None,ClientManager)
ClientManager.regBot = new_instancemethod(_pyadchpp.ClientManager_regBot,None,ClientManager)
ClientManager.getEntities = new_instancemethod(_pyadchpp.ClientManager_getEntities,None,ClientManager)
ClientManager.findByCID = new_instancemethod(_pyadchpp.ClientManager_findByCID,None,ClientManager)
ClientManager.findByNick = new_instancemethod(_pyadchpp.ClientManager_findByNick,None,ClientManager)
ClientManager.send = new_instancemethod(_pyadchpp.ClientManager_send,None,ClientManager)
ClientManager.sendToAll = new_instancemethod(_pyadchpp.ClientManager_sendToAll,None,ClientManager)
ClientManager.sendTo = new_instancemethod(_pyadchpp.ClientManager_sendTo,None,ClientManager)
ClientManager.enterIdentify = new_instancemethod(_pyadchpp.ClientManager_enterIdentify,None,ClientManager)
ClientManager.enterVerify = new_instancemethod(_pyadchpp.ClientManager_enterVerify,None,ClientManager)
ClientManager.enterNormal = new_instancemethod(_pyadchpp.ClientManager_enterNormal,None,ClientManager)
ClientManager.verifySUP = new_instancemethod(_pyadchpp.ClientManager_verifySUP,None,ClientManager)
ClientManager.verifyINF = new_instancemethod(_pyadchpp.ClientManager_verifyINF,None,ClientManager)
ClientManager.verifyNick = new_instancemethod(_pyadchpp.ClientManager_verifyNick,None,ClientManager)
ClientManager.verifyPassword = new_instancemethod(_pyadchpp.ClientManager_verifyPassword,None,ClientManager)
ClientManager.verifyHashedPassword = new_instancemethod(_pyadchpp.ClientManager_verifyHashedPassword,None,ClientManager)
ClientManager.verifyIp = new_instancemethod(_pyadchpp.ClientManager_verifyIp,None,ClientManager)
ClientManager.verifyCID = new_instancemethod(_pyadchpp.ClientManager_verifyCID,None,ClientManager)
ClientManager.verifyOverflow = new_instancemethod(_pyadchpp.ClientManager_verifyOverflow,None,ClientManager)
ClientManager.setState = new_instancemethod(_pyadchpp.ClientManager_setState,None,ClientManager)
ClientManager.getQueuedBytes = new_instancemethod(_pyadchpp.ClientManager_getQueuedBytes,None,ClientManager)
ClientManager.signalConnected = new_instancemethod(_pyadchpp.ClientManager_signalConnected,None,ClientManager)
ClientManager.signalReady = new_instancemethod(_pyadchpp.ClientManager_signalReady,None,ClientManager)
ClientManager.signalReceive = new_instancemethod(_pyadchpp.ClientManager_signalReceive,None,ClientManager)
ClientManager.signalBadLine = new_instancemethod(_pyadchpp.ClientManager_signalBadLine,None,ClientManager)
ClientManager.signalSend = new_instancemethod(_pyadchpp.ClientManager_signalSend,None,ClientManager)
ClientManager.signalState = new_instancemethod(_pyadchpp.ClientManager_signalState,None,ClientManager)
ClientManager.signalDisconnected = new_instancemethod(_pyadchpp.ClientManager_signalDisconnected,None,ClientManager)
ClientManager.setMaxCommandSize = new_instancemethod(_pyadchpp.ClientManager_setMaxCommandSize,None,ClientManager)
ClientManager.getMaxCommandSize = new_instancemethod(_pyadchpp.ClientManager_getMaxCommandSize,None,ClientManager)
ClientManager.setLogTimeout = new_instancemethod(_pyadchpp.ClientManager_setLogTimeout,None,ClientManager)
ClientManager.getLogTimeout = new_instancemethod(_pyadchpp.ClientManager_getLogTimeout,None,ClientManager)
ClientManager.createBot = new_instancemethod(_pyadchpp.ClientManager_createBot,None,ClientManager)
ClientManager_swigregister = _pyadchpp.ClientManager_swigregister
ClientManager_swigregister(ClientManager)

class SimpleXML(object):
    """Proxy of C++ adchpp::SimpleXML class"""
    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, numAttribs=0): 
        """
        __init__(adchpp::SimpleXML self, int numAttribs=0) -> SimpleXML
        __init__(adchpp::SimpleXML self) -> SimpleXML
        """
        _pyadchpp.SimpleXML_swiginit(self,_pyadchpp.new_SimpleXML(numAttribs))
    __swig_destroy__ = _pyadchpp.delete_SimpleXML
    def addTag(self, *args):
        """
        addTag(SimpleXML self, std::string const & aName, std::string const & aData=emptyString)
        addTag(SimpleXML self, std::string const & aName)
        """
        return _pyadchpp.SimpleXML_addTag(self, *args)

    def addAttrib(self, *args):
        """addAttrib(SimpleXML self, std::string const & aName, std::string const & aData)"""
        return _pyadchpp.SimpleXML_addAttrib(self, *args)

    def addChildAttrib(self, *args):
        """addChildAttrib(SimpleXML self, std::string const & aName, std::string const & aData)"""
        return _pyadchpp.SimpleXML_addChildAttrib(self, *args)

    def getData(self):
        """getData(SimpleXML self) -> std::string const &"""
        return _pyadchpp.SimpleXML_getData(self)

    def stepIn(self):
        """stepIn(SimpleXML self)"""
        return _pyadchpp.SimpleXML_stepIn(self)

    def stepOut(self):
        """stepOut(SimpleXML self)"""
        return _pyadchpp.SimpleXML_stepOut(self)

    def resetCurrentChild(self):
        """resetCurrentChild(SimpleXML self)"""
        return _pyadchpp.SimpleXML_resetCurrentChild(self)

    def findChild(self, *args):
        """findChild(SimpleXML self, std::string const & aName) -> bool"""
        return _pyadchpp.SimpleXML_findChild(self, *args)

    def getChildName(self):
        """getChildName(SimpleXML self) -> std::string const &"""
        return _pyadchpp.SimpleXML_getChildName(self)

    def getChildData(self):
        """getChildData(SimpleXML self) -> std::string const &"""
        return _pyadchpp.SimpleXML_getChildData(self)

    def getChildAttrib(self, *args):
        """
        getChildAttrib(SimpleXML self, std::string const & aName, std::string const & aDefault=emptyString) -> std::string const
        getChildAttrib(SimpleXML self, std::string const & aName) -> std::string const &
        """
        return _pyadchpp.SimpleXML_getChildAttrib(self, *args)

    def getIntChildAttrib(self, *args):
        """getIntChildAttrib(SimpleXML self, std::string const & aName) -> int"""
        return _pyadchpp.SimpleXML_getIntChildAttrib(self, *args)

    def getLongLongChildAttrib(self, *args):
        """getLongLongChildAttrib(SimpleXML self, std::string const & aName) -> int64_t"""
        return _pyadchpp.SimpleXML_getLongLongChildAttrib(self, *args)

    def getBoolChildAttrib(self, *args):
        """getBoolChildAttrib(SimpleXML self, std::string const & aName) -> bool"""
        return _pyadchpp.SimpleXML_getBoolChildAttrib(self, *args)

    def fromXML(self, *args):
        """fromXML(SimpleXML self, std::string const & aXML)"""
        return _pyadchpp.SimpleXML_fromXML(self, *args)

    def toXML(self):
        """toXML(SimpleXML self) -> std::string"""
        return _pyadchpp.SimpleXML_toXML(self)

    def escape(*args):
        """
        escape(std::string & aString, bool aAttrib, bool aLoading=False)
        escape(std::string & aString, bool aAttrib)
        """
        return _pyadchpp.SimpleXML_escape(*args)

    escape = staticmethod(escape)
    def needsEscape(*args):
        """
        needsEscape(std::string const & aString, bool aAttrib, bool aLoading=False) -> bool
        needsEscape(std::string const & aString, bool aAttrib) -> bool
        """
        return _pyadchpp.SimpleXML_needsEscape(*args)

    needsEscape = staticmethod(needsEscape)
SimpleXML.addTag = new_instancemethod(_pyadchpp.SimpleXML_addTag,None,SimpleXML)
SimpleXML.addAttrib = new_instancemethod(_pyadchpp.SimpleXML_addAttrib,None,SimpleXML)
SimpleXML.addChildAttrib = new_instancemethod(_pyadchpp.SimpleXML_addChildAttrib,None,SimpleXML)
SimpleXML.getData = new_instancemethod(_pyadchpp.SimpleXML_getData,None,SimpleXML)
SimpleXML.stepIn = new_instancemethod(_pyadchpp.SimpleXML_stepIn,None,SimpleXML)
SimpleXML.stepOut = new_instancemethod(_pyadchpp.SimpleXML_stepOut,None,SimpleXML)
SimpleXML.resetCurrentChild = new_instancemethod(_pyadchpp.SimpleXML_resetCurrentChild,None,SimpleXML)
SimpleXML.findChild = new_instancemethod(_pyadchpp.SimpleXML_findChild,None,SimpleXML)
SimpleXML.getChildName = new_instancemethod(_pyadchpp.SimpleXML_getChildName,None,SimpleXML)
SimpleXML.getChildData = new_instancemethod(_pyadchpp.SimpleXML_getChildData,None,SimpleXML)
SimpleXML.getChildAttrib = new_instancemethod(_pyadchpp.SimpleXML_getChildAttrib,None,SimpleXML)
SimpleXML.getIntChildAttrib = new_instancemethod(_pyadchpp.SimpleXML_getIntChildAttrib,None,SimpleXML)
SimpleXML.getLongLongChildAttrib = new_instancemethod(_pyadchpp.SimpleXML_getLongLongChildAttrib,None,SimpleXML)
SimpleXML.getBoolChildAttrib = new_instancemethod(_pyadchpp.SimpleXML_getBoolChildAttrib,None,SimpleXML)
SimpleXML.fromXML = new_instancemethod(_pyadchpp.SimpleXML_fromXML,None,SimpleXML)
SimpleXML.toXML = new_instancemethod(_pyadchpp.SimpleXML_toXML,None,SimpleXML)
SimpleXML_swigregister = _pyadchpp.SimpleXML_swigregister
SimpleXML_swigregister(SimpleXML)

def SimpleXML_escape(*args):
  """
    escape(std::string & aString, bool aAttrib, bool aLoading=False)
    SimpleXML_escape(std::string & aString, bool aAttrib)
    """
  return _pyadchpp.SimpleXML_escape(*args)

def SimpleXML_needsEscape(*args):
  """
    needsEscape(std::string const & aString, bool aAttrib, bool aLoading=False) -> bool
    SimpleXML_needsEscape(std::string const & aString, bool aAttrib) -> bool
    """
  return _pyadchpp.SimpleXML_needsEscape(*args)

class TigerHash(object):
    """Proxy of C++ adchpp::TigerHash class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    __repr__ = _swig_repr
    BITS = _pyadchpp.TigerHash_BITS
    BYTES = _pyadchpp.TigerHash_BYTES
    def __init__(self): 
        """__init__(adchpp::TigerHash self) -> TigerHash"""
        _pyadchpp.TigerHash_swiginit(self,_pyadchpp.new_TigerHash())
    def update(self, *args):
        """update(TigerHash self, std::string const & data)"""
        return _pyadchpp.TigerHash_update(self, *args)

    def finalize(self):
        """finalize(TigerHash self) -> std::string"""
        return _pyadchpp.TigerHash_finalize(self)

    __swig_destroy__ = _pyadchpp.delete_TigerHash
TigerHash.update = new_instancemethod(_pyadchpp.TigerHash_update,None,TigerHash)
TigerHash.finalize = new_instancemethod(_pyadchpp.TigerHash_finalize,None,TigerHash)
TigerHash_swigregister = _pyadchpp.TigerHash_swigregister
TigerHash_swigregister(TigerHash)

class Encoder(object):
    """Proxy of C++ adchpp::Encoder class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def toBase32(*args):
        """toBase32(std::string const & src) -> std::string"""
        return _pyadchpp.Encoder_toBase32(*args)

    toBase32 = staticmethod(toBase32)
    def fromBase32(*args):
        """fromBase32(std::string const & src) -> std::string"""
        return _pyadchpp.Encoder_fromBase32(*args)

    fromBase32 = staticmethod(fromBase32)
    __swig_destroy__ = _pyadchpp.delete_Encoder
Encoder_swigregister = _pyadchpp.Encoder_swigregister
Encoder_swigregister(Encoder)

def Encoder_toBase32(*args):
  """Encoder_toBase32(std::string const & src) -> std::string"""
  return _pyadchpp.Encoder_toBase32(*args)

def Encoder_fromBase32(*args):
  """Encoder_fromBase32(std::string const & src) -> std::string"""
  return _pyadchpp.Encoder_fromBase32(*args)

class Plugin(object):
    """Proxy of C++ adchpp::Plugin class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _pyadchpp.delete_Plugin
    def getVersion(self):
        """getVersion(Plugin self) -> int"""
        return _pyadchpp.Plugin_getVersion(self)

Plugin.getVersion = new_instancemethod(_pyadchpp.Plugin_getVersion,None,Plugin)
Plugin_swigregister = _pyadchpp.Plugin_swigregister
Plugin_swigregister(Plugin)

class PluginManager(object):
    """Proxy of C++ adchpp::PluginManager class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def attention(self, *args):
        """attention(PluginManager self, std::function< void () > f)"""
        return _pyadchpp.PluginManager_attention(self, *args)

    def getPluginList(self):
        """getPluginList(PluginManager self) -> TStringList"""
        return _pyadchpp.PluginManager_getPluginList(self)

    def getPluginPath(self):
        """getPluginPath(PluginManager self) -> std::string const &"""
        return _pyadchpp.PluginManager_getPluginPath(self)

    def setPluginList(self, *args):
        """setPluginList(PluginManager self, TStringList pluginList)"""
        return _pyadchpp.PluginManager_setPluginList(self, *args)

    def setPluginPath(self, *args):
        """setPluginPath(PluginManager self, std::string const & name)"""
        return _pyadchpp.PluginManager_setPluginPath(self, *args)

    def registerPlugin(self, *args):
        """registerPlugin(PluginManager self, std::string const & name, shared_ptr< adchpp::Plugin > ptr) -> bool"""
        return _pyadchpp.PluginManager_registerPlugin(self, *args)

    def unregisterPlugin(self, *args):
        """unregisterPlugin(PluginManager self, std::string const & name) -> bool"""
        return _pyadchpp.PluginManager_unregisterPlugin(self, *args)

    def getPlugin(self, *args):
        """getPlugin(PluginManager self, std::string const & name) -> shared_ptr< adchpp::Plugin >"""
        return _pyadchpp.PluginManager_getPlugin(self, *args)

    def onCommand(self, *args):
        """onCommand(PluginManager self, std::string const & commandName, adchpp::PluginManager::CommandSlot f) -> TManagedConnectionPtr"""
        return _pyadchpp.PluginManager_onCommand(self, *args)

    def getCommandSignal(self, *args):
        """getCommandSignal(PluginManager self, std::string const & commandName) -> SignalESB"""
        return _pyadchpp.PluginManager_getCommandSignal(self, *args)

    def registerPluginData(self):
        """registerPluginData(PluginManager self) -> PluginDataHandle"""
        return _pyadchpp.PluginManager_registerPluginData(self)

    pluginPath = property(getPluginPath,setPluginPath) 
    pluginList = property(getPluginList,setPluginList) 
PluginManager.attention = new_instancemethod(_pyadchpp.PluginManager_attention,None,PluginManager)
PluginManager.getPluginList = new_instancemethod(_pyadchpp.PluginManager_getPluginList,None,PluginManager)
PluginManager.getPluginPath = new_instancemethod(_pyadchpp.PluginManager_getPluginPath,None,PluginManager)
PluginManager.setPluginList = new_instancemethod(_pyadchpp.PluginManager_setPluginList,None,PluginManager)
PluginManager.setPluginPath = new_instancemethod(_pyadchpp.PluginManager_setPluginPath,None,PluginManager)
PluginManager.registerPlugin = new_instancemethod(_pyadchpp.PluginManager_registerPlugin,None,PluginManager)
PluginManager.unregisterPlugin = new_instancemethod(_pyadchpp.PluginManager_unregisterPlugin,None,PluginManager)
PluginManager.getPlugin = new_instancemethod(_pyadchpp.PluginManager_getPlugin,None,PluginManager)
PluginManager.onCommand = new_instancemethod(_pyadchpp.PluginManager_onCommand,None,PluginManager)
PluginManager.getCommandSignal = new_instancemethod(_pyadchpp.PluginManager_getCommandSignal,None,PluginManager)
PluginManager.registerPluginData = new_instancemethod(_pyadchpp.PluginManager_registerPluginData,None,PluginManager)
PluginManager_swigregister = _pyadchpp.PluginManager_swigregister
PluginManager_swigregister(PluginManager)

class TCorePtr(object):
    """Proxy of C++ shared_ptr<(adchpp::Core)> class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def __deref__(self):
        """__deref__(TCorePtr self) -> Core"""
        return _pyadchpp.TCorePtr___deref__(self)

    __swig_destroy__ = _pyadchpp.delete_TCorePtr
    def create(self, *args):
        """create(TCorePtr self, std::string const & configPath) -> TCorePtr"""
        return _pyadchpp.TCorePtr_create(self, *args)

    def run(self):
        """run(TCorePtr self)"""
        return _pyadchpp.TCorePtr_run(self)

    def shutdown(self):
        """shutdown(TCorePtr self)"""
        return _pyadchpp.TCorePtr_shutdown(self)

    def getLogManager(self):
        """getLogManager(TCorePtr self) -> LogManager"""
        return _pyadchpp.TCorePtr_getLogManager(self)

    def getSocketManager(self):
        """getSocketManager(TCorePtr self) -> SocketManager"""
        return _pyadchpp.TCorePtr_getSocketManager(self)

    def getPluginManager(self):
        """getPluginManager(TCorePtr self) -> PluginManager"""
        return _pyadchpp.TCorePtr_getPluginManager(self)

    def getClientManager(self):
        """getClientManager(TCorePtr self) -> ClientManager"""
        return _pyadchpp.TCorePtr_getClientManager(self)

    def getConfigPath(self):
        """getConfigPath(TCorePtr self) -> std::string const &"""
        return _pyadchpp.TCorePtr_getConfigPath(self)

    def addJob(self, *args):
        """addJob(TCorePtr self, long const msec, adchpp::Core::Callback callback)"""
        return _pyadchpp.TCorePtr_addJob(self, *args)

    def addJob_str(self, *args):
        """addJob_str(TCorePtr self, std::string const & time, adchpp::Core::Callback callback)"""
        return _pyadchpp.TCorePtr_addJob_str(self, *args)

    def addTimedJob(self, *args):
        """addTimedJob(TCorePtr self, long const msec, adchpp::Core::Callback callback) -> adchpp::Core::Callback"""
        return _pyadchpp.TCorePtr_addTimedJob(self, *args)

    def addTimedJob_str(self, *args):
        """addTimedJob_str(TCorePtr self, std::string const & time, adchpp::Core::Callback callback) -> adchpp::Core::Callback"""
        return _pyadchpp.TCorePtr_addTimedJob_str(self, *args)

    def getStartTime(self):
        """getStartTime(TCorePtr self) -> time_t"""
        return _pyadchpp.TCorePtr_getStartTime(self)

    def getUpTime(self):
        """getUpTime(TCorePtr self) -> uint32_t"""
        return _pyadchpp.TCorePtr_getUpTime(self)

TCorePtr.__deref__ = new_instancemethod(_pyadchpp.TCorePtr___deref__,None,TCorePtr)
TCorePtr.create = new_instancemethod(_pyadchpp.TCorePtr_create,None,TCorePtr)
TCorePtr.run = new_instancemethod(_pyadchpp.TCorePtr_run,None,TCorePtr)
TCorePtr.shutdown = new_instancemethod(_pyadchpp.TCorePtr_shutdown,None,TCorePtr)
TCorePtr.getLogManager = new_instancemethod(_pyadchpp.TCorePtr_getLogManager,None,TCorePtr)
TCorePtr.getSocketManager = new_instancemethod(_pyadchpp.TCorePtr_getSocketManager,None,TCorePtr)
TCorePtr.getPluginManager = new_instancemethod(_pyadchpp.TCorePtr_getPluginManager,None,TCorePtr)
TCorePtr.getClientManager = new_instancemethod(_pyadchpp.TCorePtr_getClientManager,None,TCorePtr)
TCorePtr.getConfigPath = new_instancemethod(_pyadchpp.TCorePtr_getConfigPath,None,TCorePtr)
TCorePtr.addJob = new_instancemethod(_pyadchpp.TCorePtr_addJob,None,TCorePtr)
TCorePtr.addJob_str = new_instancemethod(_pyadchpp.TCorePtr_addJob_str,None,TCorePtr)
TCorePtr.addTimedJob = new_instancemethod(_pyadchpp.TCorePtr_addTimedJob,None,TCorePtr)
TCorePtr.addTimedJob_str = new_instancemethod(_pyadchpp.TCorePtr_addTimedJob_str,None,TCorePtr)
TCorePtr.getStartTime = new_instancemethod(_pyadchpp.TCorePtr_getStartTime,None,TCorePtr)
TCorePtr.getUpTime = new_instancemethod(_pyadchpp.TCorePtr_getUpTime,None,TCorePtr)
TCorePtr_swigregister = _pyadchpp.TCorePtr_swigregister
TCorePtr_swigregister(TCorePtr)

class Core(object):
    """Proxy of C++ adchpp::Core class"""
    thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def create(*args):
        """create(std::string const & configPath) -> TCorePtr"""
        return _pyadchpp.Core_create(*args)

    create = staticmethod(create)
    def run(self):
        """run(Core self)"""
        return _pyadchpp.Core_run(self)

    def shutdown(self):
        """shutdown(Core self)"""
        return _pyadchpp.Core_shutdown(self)

    def getLogManager(self):
        """getLogManager(Core self) -> LogManager"""
        return _pyadchpp.Core_getLogManager(self)

    def getSocketManager(self):
        """getSocketManager(Core self) -> SocketManager"""
        return _pyadchpp.Core_getSocketManager(self)

    def getPluginManager(self):
        """getPluginManager(Core self) -> PluginManager"""
        return _pyadchpp.Core_getPluginManager(self)

    def getClientManager(self):
        """getClientManager(Core self) -> ClientManager"""
        return _pyadchpp.Core_getClientManager(self)

    def getConfigPath(self):
        """getConfigPath(Core self) -> std::string const &"""
        return _pyadchpp.Core_getConfigPath(self)

    def addJob(self, *args):
        """addJob(Core self, long const msec, adchpp::Core::Callback callback)"""
        return _pyadchpp.Core_addJob(self, *args)

    def addJob_str(self, *args):
        """addJob_str(Core self, std::string const & time, adchpp::Core::Callback callback)"""
        return _pyadchpp.Core_addJob_str(self, *args)

    def addTimedJob(self, *args):
        """addTimedJob(Core self, long const msec, adchpp::Core::Callback callback) -> adchpp::Core::Callback"""
        return _pyadchpp.Core_addTimedJob(self, *args)

    def addTimedJob_str(self, *args):
        """addTimedJob_str(Core self, std::string const & time, adchpp::Core::Callback callback) -> adchpp::Core::Callback"""
        return _pyadchpp.Core_addTimedJob_str(self, *args)

    def getStartTime(self):
        """getStartTime(Core self) -> time_t"""
        return _pyadchpp.Core_getStartTime(self)

    def getUpTime(self):
        """getUpTime(Core self) -> uint32_t"""
        return _pyadchpp.Core_getUpTime(self)

    __swig_destroy__ = _pyadchpp.delete_Core
Core.run = new_instancemethod(_pyadchpp.Core_run,None,Core)
Core.shutdown = new_instancemethod(_pyadchpp.Core_shutdown,None,Core)
Core.getLogManager = new_instancemethod(_pyadchpp.Core_getLogManager,None,Core)
Core.getSocketManager = new_instancemethod(_pyadchpp.Core_getSocketManager,None,Core)
Core.getPluginManager = new_instancemethod(_pyadchpp.Core_getPluginManager,None,Core)
Core.getClientManager = new_instancemethod(_pyadchpp.Core_getClientManager,None,Core)
Core.getConfigPath = new_instancemethod(_pyadchpp.Core_getConfigPath,None,Core)
Core.addJob = new_instancemethod(_pyadchpp.Core_addJob,None,Core)
Core.addJob_str = new_instancemethod(_pyadchpp.Core_addJob_str,None,Core)
Core.addTimedJob = new_instancemethod(_pyadchpp.Core_addTimedJob,None,Core)
Core.addTimedJob_str = new_instancemethod(_pyadchpp.Core_addTimedJob_str,None,Core)
Core.getStartTime = new_instancemethod(_pyadchpp.Core_getStartTime,None,Core)
Core.getUpTime = new_instancemethod(_pyadchpp.Core_getUpTime,None,Core)
Core_swigregister = _pyadchpp.Core_swigregister
Core_swigregister(Core)

def Core_create(*args):
  """Core_create(std::string const & configPath) -> TCorePtr"""
  return _pyadchpp.Core_create(*args)



