nordugrid-arc-python 5.0.5-1ubuntu1 / usr / lib / python2.7 / dist-packages / arc / common.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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 >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_common', [dirname(__file__)])
        except ImportError:
            from arc import _common
            return _common
        if fp is not None:
            try:
                _mod = imp.load_module('_common', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _common = swig_import_helper()
    del swig_import_helper
else:
    from arc import _common
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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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

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


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_SwigPyIterator
    __del__ = lambda self: None

    def value(self):
        return _common.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _common.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _common.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _common.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _common.SwigPyIterator_equal(self, x)

    def copy(self):
        return _common.SwigPyIterator_copy(self)

    def next(self):
        return _common.SwigPyIterator_next(self)

    def __next__(self):
        return _common.SwigPyIterator___next__(self)

    def previous(self):
        return _common.SwigPyIterator_previous(self)

    def advance(self, n):
        return _common.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _common.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _common.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _common.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _common.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _common.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        return _common.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _common.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)


import warnings

def deprecated(method):
    """This decorator is used to mark python methods as deprecated, _not_
    functions. It will result in a warning being emmitted when the method
    is used."""
    def newMethod(*args, **kwargs):
        warnings.warn("Call to deprecated method 'arc.%s.%s'." % (args[0].__class__.__name__, method.__name__), category = DeprecationWarning, stacklevel = 2)
        return method(*args, **kwargs)
    newMethod.__name__ = method.__name__
    newMethod.__doc__ = method.__doc__
    newMethod.__dict__.update(method.__dict__)
    return newMethod


class StaticPropertyWrapper(object):
    def __init__(self, wrapped_class):
        object.__setattr__(self, "wrapped_class", wrapped_class)

    def __getattr__(self, name):
        orig_attr = getattr(self.wrapped_class, name)
        if isinstance(orig_attr, property):
            return orig_attr.fget()
        else:
            return orig_attr

    def __setattr__(self, name, value):
        orig_attr = getattr(self.wrapped_class, name)
        if isinstance(orig_attr, property):
            orig_attr.fset(value)
        else:
            setattr(self.wrapped_class, name, value)



class StringPair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringPair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringPair, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_StringPair(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_setmethods__["first"] = _common.StringPair_first_set
    __swig_getmethods__["first"] = _common.StringPair_first_get
    if _newclass:
        first = _swig_property(_common.StringPair_first_get, _common.StringPair_first_set)
    __swig_setmethods__["second"] = _common.StringPair_second_set
    __swig_getmethods__["second"] = _common.StringPair_second_get
    if _newclass:
        second = _swig_property(_common.StringPair_second_get, _common.StringPair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _common.delete_StringPair
    __del__ = lambda self: None
StringPair_swigregister = _common.StringPair_swigregister
StringPair_swigregister(StringPair)

class StringList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.StringList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.StringList___nonzero__(self)

    def __bool__(self):
        return _common.StringList___bool__(self)

    def __len__(self):
        return _common.StringList___len__(self)

    def __getslice__(self, i, j):
        return _common.StringList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.StringList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.StringList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.StringList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.StringList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.StringList___setitem__(self, *args)

    def pop(self):
        return _common.StringList_pop(self)

    def append(self, x):
        return _common.StringList_append(self, x)

    def empty(self):
        return _common.StringList_empty(self)

    def size(self):
        return _common.StringList_size(self)

    def swap(self, v):
        return _common.StringList_swap(self, v)

    def begin(self):
        return _common.StringList_begin(self)

    def end(self):
        return _common.StringList_end(self)

    def rbegin(self):
        return _common.StringList_rbegin(self)

    def rend(self):
        return _common.StringList_rend(self)

    def clear(self):
        return _common.StringList_clear(self)

    def get_allocator(self):
        return _common.StringList_get_allocator(self)

    def pop_back(self):
        return _common.StringList_pop_back(self)

    def erase(self, *args):
        return _common.StringList_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_StringList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.StringList_push_back(self, x)

    def front(self):
        return _common.StringList_front(self)

    def back(self):
        return _common.StringList_back(self)

    def assign(self, n, x):
        return _common.StringList_assign(self, n, x)

    def resize(self, *args):
        return _common.StringList_resize(self, *args)

    def insert(self, *args):
        return _common.StringList_insert(self, *args)

    def pop_front(self):
        return _common.StringList_pop_front(self)

    def push_front(self, x):
        return _common.StringList_push_front(self, x)

    def reverse(self):
        return _common.StringList_reverse(self)
    __swig_destroy__ = _common.delete_StringList
    __del__ = lambda self: None
StringList_swigregister = _common.StringList_swigregister
StringList_swigregister(StringList)

class StringSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringSet, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.StringSet_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.StringSet___nonzero__(self)

    def __bool__(self):
        return _common.StringSet___bool__(self)

    def __len__(self):
        return _common.StringSet___len__(self)

    def append(self, x):
        return _common.StringSet_append(self, x)

    def __contains__(self, x):
        return _common.StringSet___contains__(self, x)

    def __getitem__(self, i):
        return _common.StringSet___getitem__(self, i)

    def add(self, x):
        return _common.StringSet_add(self, x)

    def discard(self, x):
        return _common.StringSet_discard(self, x)

    def __init__(self, *args):
        this = _common.new_StringSet(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _common.StringSet_empty(self)

    def size(self):
        return _common.StringSet_size(self)

    def clear(self):
        return _common.StringSet_clear(self)

    def swap(self, v):
        return _common.StringSet_swap(self, v)

    def count(self, x):
        return _common.StringSet_count(self, x)

    def begin(self):
        return _common.StringSet_begin(self)

    def end(self):
        return _common.StringSet_end(self)

    def rbegin(self):
        return _common.StringSet_rbegin(self)

    def rend(self):
        return _common.StringSet_rend(self)

    def erase(self, *args):
        return _common.StringSet_erase(self, *args)

    def find(self, x):
        return _common.StringSet_find(self, x)

    def lower_bound(self, x):
        return _common.StringSet_lower_bound(self, x)

    def upper_bound(self, x):
        return _common.StringSet_upper_bound(self, x)

    def equal_range(self, x):
        return _common.StringSet_equal_range(self, x)

    def insert(self, __x):
        return _common.StringSet_insert(self, __x)
    __swig_destroy__ = _common.delete_StringSet
    __del__ = lambda self: None
StringSet_swigregister = _common.StringSet_swigregister
StringSet_swigregister(StringSet)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.StringVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.StringVector___nonzero__(self)

    def __bool__(self):
        return _common.StringVector___bool__(self)

    def __len__(self):
        return _common.StringVector___len__(self)

    def __getslice__(self, i, j):
        return _common.StringVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.StringVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.StringVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.StringVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.StringVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.StringVector___setitem__(self, *args)

    def pop(self):
        return _common.StringVector_pop(self)

    def append(self, x):
        return _common.StringVector_append(self, x)

    def empty(self):
        return _common.StringVector_empty(self)

    def size(self):
        return _common.StringVector_size(self)

    def swap(self, v):
        return _common.StringVector_swap(self, v)

    def begin(self):
        return _common.StringVector_begin(self)

    def end(self):
        return _common.StringVector_end(self)

    def rbegin(self):
        return _common.StringVector_rbegin(self)

    def rend(self):
        return _common.StringVector_rend(self)

    def clear(self):
        return _common.StringVector_clear(self)

    def get_allocator(self):
        return _common.StringVector_get_allocator(self)

    def pop_back(self):
        return _common.StringVector_pop_back(self)

    def erase(self, *args):
        return _common.StringVector_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_StringVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.StringVector_push_back(self, x)

    def front(self):
        return _common.StringVector_front(self)

    def back(self):
        return _common.StringVector_back(self)

    def assign(self, n, x):
        return _common.StringVector_assign(self, n, x)

    def resize(self, *args):
        return _common.StringVector_resize(self, *args)

    def insert(self, *args):
        return _common.StringVector_insert(self, *args)

    def reserve(self, n):
        return _common.StringVector_reserve(self, n)

    def capacity(self):
        return _common.StringVector_capacity(self)
    __swig_destroy__ = _common.delete_StringVector
    __del__ = lambda self: None
StringVector_swigregister = _common.StringVector_swigregister
StringVector_swigregister(StringVector)

class StringStringMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringStringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringStringMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.StringStringMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.StringStringMap___nonzero__(self)

    def __bool__(self):
        return _common.StringStringMap___bool__(self)

    def __len__(self):
        return _common.StringStringMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _common.StringStringMap___getitem__(self, key)

    def __delitem__(self, key):
        return _common.StringStringMap___delitem__(self, key)

    def has_key(self, key):
        return _common.StringStringMap_has_key(self, key)

    def keys(self):
        return _common.StringStringMap_keys(self)

    def values(self):
        return _common.StringStringMap_values(self)

    def items(self):
        return _common.StringStringMap_items(self)

    def __contains__(self, key):
        return _common.StringStringMap___contains__(self, key)

    def key_iterator(self):
        return _common.StringStringMap_key_iterator(self)

    def value_iterator(self):
        return _common.StringStringMap_value_iterator(self)

    def __setitem__(self, *args):
        return _common.StringStringMap___setitem__(self, *args)

    def asdict(self):
        return _common.StringStringMap_asdict(self)

    def __init__(self, *args):
        this = _common.new_StringStringMap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _common.StringStringMap_empty(self)

    def size(self):
        return _common.StringStringMap_size(self)

    def swap(self, v):
        return _common.StringStringMap_swap(self, v)

    def begin(self):
        return _common.StringStringMap_begin(self)

    def end(self):
        return _common.StringStringMap_end(self)

    def rbegin(self):
        return _common.StringStringMap_rbegin(self)

    def rend(self):
        return _common.StringStringMap_rend(self)

    def clear(self):
        return _common.StringStringMap_clear(self)

    def get_allocator(self):
        return _common.StringStringMap_get_allocator(self)

    def count(self, x):
        return _common.StringStringMap_count(self, x)

    def erase(self, *args):
        return _common.StringStringMap_erase(self, *args)

    def find(self, x):
        return _common.StringStringMap_find(self, x)

    def lower_bound(self, x):
        return _common.StringStringMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _common.StringStringMap_upper_bound(self, x)
    __swig_destroy__ = _common.delete_StringStringMap
    __del__ = lambda self: None
StringStringMap_swigregister = _common.StringStringMap_swigregister
StringStringMap_swigregister(StringStringMap)

class NS(StringStringMap):
    __swig_setmethods__ = {}
    for _s in [StringStringMap]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NS, name, value)
    __swig_getmethods__ = {}
    for _s in [StringStringMap]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, NS, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_NS(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_NS
    __del__ = lambda self: None
NS_swigregister = _common.NS_swigregister
NS_swigregister(NS)

class XMLNode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNode, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_XMLNode(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_XMLNode
    __del__ = lambda self: None

    def New(self, node):
        return _common.XMLNode_New(self, node)

    def Exchange(self, node):
        return _common.XMLNode_Exchange(self, node)

    def Move(self, node):
        return _common.XMLNode_Move(self, node)

    def Swap(self, node):
        return _common.XMLNode_Swap(self, node)

    def __nonzero__(self):
        return _common.XMLNode___nonzero__(self)
    __bool__ = __nonzero__



    def Same(self, node):
        return _common.XMLNode_Same(self, node)

    def __eq__(self, *args):
        return _common.XMLNode___eq__(self, *args)

    def __ne__(self, *args):
        return _common.XMLNode___ne__(self, *args)

    def Child(self, n=0):
        return _common.XMLNode_Child(self, n)

    def Size(self):
        return _common.XMLNode_Size(self)

    def Get(self, name):
        return _common.XMLNode_Get(self, name)

    def FullName(self):
        return _common.XMLNode_FullName(self)

    def Namespace(self):
        return _common.XMLNode_Namespace(self)

    def Prefix(self, *args):
        return _common.XMLNode_Prefix(self, *args)

    def StripNamespace(self, recursion=0):
        return _common.XMLNode_StripNamespace(self, recursion)

    def Name(self, *args):
        return _common.XMLNode_Name(self, *args)

    def GetXML(self, *args):
        return _common.XMLNode_GetXML(self, *args)

    def GetDoc(self, user_friendly=False):
        return _common.XMLNode_GetDoc(self, user_friendly)

    def __str__(self):
        return _common.XMLNode___str__(self)

    def Set(self, content):
        return _common.XMLNode_Set(self, content)

    def Attribute(self, *args):
        return _common.XMLNode_Attribute(self, *args)

    def NewAttribute(self, *args):
        return _common.XMLNode_NewAttribute(self, *args)

    def AttributesSize(self):
        return _common.XMLNode_AttributesSize(self)

    def Namespaces(self, *args):
        return _common.XMLNode_Namespaces(self, *args)

    def NamespacePrefix(self, urn):
        return _common.XMLNode_NamespacePrefix(self, urn)

    def NewChild(self, *args):
        return _common.XMLNode_NewChild(self, *args)

    def Replace(self, node):
        return _common.XMLNode_Replace(self, node)

    def Destroy(self):
        return _common.XMLNode_Destroy(self)

    def Path(self, path):
        return _common.XMLNode_Path(self, path)

    def XPathLookup(self, xpathExpr, nsList):
        return _common.XMLNode_XPathLookup(self, xpathExpr, nsList)

    def GetRoot(self):
        return _common.XMLNode_GetRoot(self)

    def Parent(self):
        return _common.XMLNode_Parent(self)

    def SaveToFile(self, file_name):
        return _common.XMLNode_SaveToFile(self, file_name)

    def SaveToStream(self, out):
        return _common.XMLNode_SaveToStream(self, out)

    def ReadFromFile(self, file_name):
        return _common.XMLNode_ReadFromFile(self, file_name)

    def ReadFromStream(self, arg2):
        return _common.XMLNode_ReadFromStream(self, arg2)

    def Validate(self, *args):
        return _common.XMLNode_Validate(self, *args)
XMLNode_swigregister = _common.XMLNode_swigregister
XMLNode_swigregister(XMLNode)


def __rshift__(arg1, node):
    return _common.__rshift__(arg1, node)
__rshift__ = _common.__rshift__
class XMLNodeContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNodeContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNodeContainer, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_XMLNodeContainer(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_XMLNodeContainer
    __del__ = lambda self: None

    def Add(self, *args):
        return _common.XMLNodeContainer_Add(self, *args)

    def AddNew(self, *args):
        return _common.XMLNodeContainer_AddNew(self, *args)

    def Size(self):
        return _common.XMLNodeContainer_Size(self)

    def Nodes(self):
        return _common.XMLNodeContainer_Nodes(self)
XMLNodeContainer_swigregister = _common.XMLNodeContainer_swigregister
XMLNodeContainer_swigregister(XMLNodeContainer)

class XMLNodeList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNodeList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNodeList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.XMLNodeList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.XMLNodeList___nonzero__(self)

    def __bool__(self):
        return _common.XMLNodeList___bool__(self)

    def __len__(self):
        return _common.XMLNodeList___len__(self)

    def __getslice__(self, i, j):
        return _common.XMLNodeList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.XMLNodeList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.XMLNodeList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.XMLNodeList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.XMLNodeList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.XMLNodeList___setitem__(self, *args)

    def pop(self):
        return _common.XMLNodeList_pop(self)

    def append(self, x):
        return _common.XMLNodeList_append(self, x)

    def empty(self):
        return _common.XMLNodeList_empty(self)

    def size(self):
        return _common.XMLNodeList_size(self)

    def swap(self, v):
        return _common.XMLNodeList_swap(self, v)

    def begin(self):
        return _common.XMLNodeList_begin(self)

    def end(self):
        return _common.XMLNodeList_end(self)

    def rbegin(self):
        return _common.XMLNodeList_rbegin(self)

    def rend(self):
        return _common.XMLNodeList_rend(self)

    def clear(self):
        return _common.XMLNodeList_clear(self)

    def get_allocator(self):
        return _common.XMLNodeList_get_allocator(self)

    def pop_back(self):
        return _common.XMLNodeList_pop_back(self)

    def erase(self, *args):
        return _common.XMLNodeList_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_XMLNodeList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.XMLNodeList_push_back(self, x)

    def front(self):
        return _common.XMLNodeList_front(self)

    def back(self):
        return _common.XMLNodeList_back(self)

    def assign(self, n, x):
        return _common.XMLNodeList_assign(self, n, x)

    def resize(self, *args):
        return _common.XMLNodeList_resize(self, *args)

    def insert(self, *args):
        return _common.XMLNodeList_insert(self, *args)

    def pop_front(self):
        return _common.XMLNodeList_pop_front(self)

    def push_front(self, x):
        return _common.XMLNodeList_push_front(self, x)

    def reverse(self):
        return _common.XMLNodeList_reverse(self)
    __swig_destroy__ = _common.delete_XMLNodeList
    __del__ = lambda self: None
XMLNodeList_swigregister = _common.XMLNodeList_swigregister
XMLNodeList_swigregister(XMLNodeList)

class Config(XMLNode):
    __swig_setmethods__ = {}
    for _s in [XMLNode]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Config, name, value)
    __swig_getmethods__ = {}
    for _s in [XMLNode]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Config, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_Config
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _common.new_Config(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def _print(self):
        return _common.Config__print(self)

    def parse(self, filename):
        return _common.Config_parse(self, filename)

    def getFileName(self):
        return _common.Config_getFileName(self)

    def setFileName(self, filename):
        return _common.Config_setFileName(self, filename)

    def save(self, filename):
        return _common.Config_save(self, filename)
Config_swigregister = _common.Config_swigregister
Config_swigregister(Config)

class BaseConfig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BaseConfig, name)
    __repr__ = _swig_repr
    __swig_setmethods__["credential"] = _common.BaseConfig_credential_set
    __swig_getmethods__["credential"] = _common.BaseConfig_credential_get
    if _newclass:
        credential = _swig_property(_common.BaseConfig_credential_get, _common.BaseConfig_credential_set)
    __swig_setmethods__["key"] = _common.BaseConfig_key_set
    __swig_getmethods__["key"] = _common.BaseConfig_key_get
    if _newclass:
        key = _swig_property(_common.BaseConfig_key_get, _common.BaseConfig_key_set)
    __swig_setmethods__["cert"] = _common.BaseConfig_cert_set
    __swig_getmethods__["cert"] = _common.BaseConfig_cert_get
    if _newclass:
        cert = _swig_property(_common.BaseConfig_cert_get, _common.BaseConfig_cert_set)
    __swig_setmethods__["proxy"] = _common.BaseConfig_proxy_set
    __swig_getmethods__["proxy"] = _common.BaseConfig_proxy_get
    if _newclass:
        proxy = _swig_property(_common.BaseConfig_proxy_get, _common.BaseConfig_proxy_set)
    __swig_setmethods__["cafile"] = _common.BaseConfig_cafile_set
    __swig_getmethods__["cafile"] = _common.BaseConfig_cafile_get
    if _newclass:
        cafile = _swig_property(_common.BaseConfig_cafile_get, _common.BaseConfig_cafile_set)
    __swig_setmethods__["cadir"] = _common.BaseConfig_cadir_set
    __swig_getmethods__["cadir"] = _common.BaseConfig_cadir_get
    if _newclass:
        cadir = _swig_property(_common.BaseConfig_cadir_get, _common.BaseConfig_cadir_set)
    __swig_setmethods__["overlay"] = _common.BaseConfig_overlay_set
    __swig_getmethods__["overlay"] = _common.BaseConfig_overlay_get
    if _newclass:
        overlay = _swig_property(_common.BaseConfig_overlay_get, _common.BaseConfig_overlay_set)

    def __init__(self):
        this = _common.new_BaseConfig()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_BaseConfig
    __del__ = lambda self: None

    def AddPluginsPath(self, path):
        return _common.BaseConfig_AddPluginsPath(self, path)

    def AddCredential(self, cred):
        return _common.BaseConfig_AddCredential(self, cred)

    def AddPrivateKey(self, path):
        return _common.BaseConfig_AddPrivateKey(self, path)

    def AddCertificate(self, path):
        return _common.BaseConfig_AddCertificate(self, path)

    def AddProxy(self, path):
        return _common.BaseConfig_AddProxy(self, path)

    def AddCAFile(self, path):
        return _common.BaseConfig_AddCAFile(self, path)

    def AddCADir(self, path):
        return _common.BaseConfig_AddCADir(self, path)

    def AddOverlay(self, cfg):
        return _common.BaseConfig_AddOverlay(self, cfg)

    def GetOverlay(self, fname):
        return _common.BaseConfig_GetOverlay(self, fname)

    def MakeConfig(self, cfg):
        return _common.BaseConfig_MakeConfig(self, cfg)
BaseConfig_swigregister = _common.BaseConfig_swigregister
BaseConfig_swigregister(BaseConfig)

class ArcLocation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArcLocation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArcLocation, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Init"] = lambda x: _common.ArcLocation_Init
    if _newclass:
        Init = staticmethod(_common.ArcLocation_Init)
    __swig_getmethods__["Get"] = lambda x: _common.ArcLocation_Get
    if _newclass:
        Get = staticmethod(_common.ArcLocation_Get)
    __swig_getmethods__["GetPlugins"] = lambda x: _common.ArcLocation_GetPlugins
    if _newclass:
        GetPlugins = staticmethod(_common.ArcLocation_GetPlugins)
    __swig_getmethods__["GetDataDir"] = lambda x: _common.ArcLocation_GetDataDir
    if _newclass:
        GetDataDir = staticmethod(_common.ArcLocation_GetDataDir)
    __swig_getmethods__["GetLibDir"] = lambda x: _common.ArcLocation_GetLibDir
    if _newclass:
        GetLibDir = staticmethod(_common.ArcLocation_GetLibDir)
    __swig_getmethods__["GetToolsDir"] = lambda x: _common.ArcLocation_GetToolsDir
    if _newclass:
        GetToolsDir = staticmethod(_common.ArcLocation_GetToolsDir)

    def __init__(self):
        this = _common.new_ArcLocation()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_ArcLocation
    __del__ = lambda self: None
ArcLocation_swigregister = _common.ArcLocation_swigregister
ArcLocation_swigregister(ArcLocation)

def ArcLocation_Init(path):
    return _common.ArcLocation_Init(path)
ArcLocation_Init = _common.ArcLocation_Init

def ArcLocation_Get():
    return _common.ArcLocation_Get()
ArcLocation_Get = _common.ArcLocation_Get

def ArcLocation_GetPlugins():
    return _common.ArcLocation_GetPlugins()
ArcLocation_GetPlugins = _common.ArcLocation_GetPlugins

def ArcLocation_GetDataDir():
    return _common.ArcLocation_GetDataDir()
ArcLocation_GetDataDir = _common.ArcLocation_GetDataDir

def ArcLocation_GetLibDir():
    return _common.ArcLocation_GetLibDir()
ArcLocation_GetLibDir = _common.ArcLocation_GetLibDir

def ArcLocation_GetToolsDir():
    return _common.ArcLocation_GetToolsDir()
ArcLocation_GetToolsDir = _common.ArcLocation_GetToolsDir


_common.ARC_VERSION_swigconstant(_common)
ARC_VERSION = _common.ARC_VERSION

_common.ARC_VERSION_NUM_swigconstant(_common)
ARC_VERSION_NUM = _common.ARC_VERSION_NUM

_common.ARC_VERSION_MAJOR_swigconstant(_common)
ARC_VERSION_MAJOR = _common.ARC_VERSION_MAJOR

_common.ARC_VERSION_MINOR_swigconstant(_common)
ARC_VERSION_MINOR = _common.ARC_VERSION_MINOR

_common.ARC_VERSION_PATCH_swigconstant(_common)
ARC_VERSION_PATCH = _common.ARC_VERSION_PATCH
class ArcVersion(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArcVersion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArcVersion, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Major"] = _common.ArcVersion_Major_get
    if _newclass:
        Major = _swig_property(_common.ArcVersion_Major_get)
    __swig_getmethods__["Minor"] = _common.ArcVersion_Minor_get
    if _newclass:
        Minor = _swig_property(_common.ArcVersion_Minor_get)
    __swig_getmethods__["Patch"] = _common.ArcVersion_Patch_get
    if _newclass:
        Patch = _swig_property(_common.ArcVersion_Patch_get)

    def __init__(self, ver):
        this = _common.new_ArcVersion(ver)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_ArcVersion
    __del__ = lambda self: None
ArcVersion_swigregister = _common.ArcVersion_swigregister
ArcVersion_swigregister(ArcVersion)

class PrintFBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PrintFBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PrintFBase, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_PrintFBase
    __del__ = lambda self: None

    def msg(self, *args):
        return _common.PrintFBase_msg(self, *args)

    def Retain(self):
        return _common.PrintFBase_Retain(self)

    def Release(self):
        return _common.PrintFBase_Release(self)
PrintFBase_swigregister = _common.PrintFBase_swigregister
PrintFBase_swigregister(PrintFBase)
cvar = _common.cvar
Version = cvar.Version


def FindTrans(p):
    return _common.FindTrans(p)
FindTrans = _common.FindTrans

def FindNTrans(s, p, n):
    return _common.FindNTrans(s, p, n)
FindNTrans = _common.FindNTrans
class IString(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IString, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_IString
    __del__ = lambda self: None

    def __init__(self, *args):
        this = _common.new_IString(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def str(self):
        return _common.IString_str(self)
IString_swigregister = _common.IString_swigregister
IString_swigregister(IString)

class CPyOutbuf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyOutbuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPyOutbuf, name)
    __repr__ = _swig_repr

    def __init__(self, obj):
        this = _common.new_CPyOutbuf(obj)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_CPyOutbuf
    __del__ = lambda self: None
CPyOutbuf_swigregister = _common.CPyOutbuf_swigregister
CPyOutbuf_swigregister(CPyOutbuf)

class CPyOstream(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyOstream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPyOstream, name)
    __repr__ = _swig_repr

    def __init__(self, obj):
        this = _common.new_CPyOstream(obj)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_CPyOstream
    __del__ = lambda self: None
CPyOstream_swigregister = _common.CPyOstream_swigregister
CPyOstream_swigregister(CPyOstream)


def LogStream(file):
    os = CPyOstream(file)
    os.thisown = False
    ls = LogStream_ostream(os)
    ls.thisown = False
    return ls



_common.DEBUG_swigconstant(_common)
DEBUG = _common.DEBUG

_common.VERBOSE_swigconstant(_common)
VERBOSE = _common.VERBOSE

_common.INFO_swigconstant(_common)
INFO = _common.INFO

_common.WARNING_swigconstant(_common)
WARNING = _common.WARNING

_common.ERROR_swigconstant(_common)
ERROR = _common.ERROR

_common.FATAL_swigconstant(_common)
FATAL = _common.FATAL

_common.LongFormat_swigconstant(_common)
LongFormat = _common.LongFormat

_common.MediumFormat_swigconstant(_common)
MediumFormat = _common.MediumFormat

_common.ShortFormat_swigconstant(_common)
ShortFormat = _common.ShortFormat

_common.DebugFormat_swigconstant(_common)
DebugFormat = _common.DebugFormat

_common.EmptyFormat_swigconstant(_common)
EmptyFormat = _common.EmptyFormat
class LoggerFormat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LoggerFormat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LoggerFormat, name)
    __repr__ = _swig_repr

    def __init__(self, format):
        this = _common.new_LoggerFormat(format)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_setmethods__["format"] = _common.LoggerFormat_format_set
    __swig_getmethods__["format"] = _common.LoggerFormat_format_get
    if _newclass:
        format = _swig_property(_common.LoggerFormat_format_get, _common.LoggerFormat_format_set)
    __swig_destroy__ = _common.delete_LoggerFormat
    __del__ = lambda self: None
LoggerFormat_swigregister = _common.LoggerFormat_swigregister
LoggerFormat_swigregister(LoggerFormat)


def istring_to_level(*args):
    return _common.istring_to_level(*args)
istring_to_level = _common.istring_to_level

def string_to_level(*args):
    return _common.string_to_level(*args)
string_to_level = _common.string_to_level

def level_to_string(level):
    return _common.level_to_string(level)
level_to_string = _common.level_to_string

def old_level_to_level(old_level):
    return _common.old_level_to_level(old_level)
old_level_to_level = _common.old_level_to_level
class LogMessage(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogMessage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogMessage, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_LogMessage(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def getLevel(self):
        return _common.LogMessage_getLevel(self)
    __swig_destroy__ = _common.delete_LogMessage
    __del__ = lambda self: None
LogMessage_swigregister = _common.LogMessage_swigregister
LogMessage_swigregister(LogMessage)

class LogDestination(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogDestination, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogDestination, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def log(self, message):
        return _common.LogDestination_log(self, message)
    __swig_destroy__ = _common.delete_LogDestination
    __del__ = lambda self: None

    def setFormat(self, newformat):
        return _common.LogDestination_setFormat(self, newformat)

    def setPrefix(self, prefix):
        return _common.LogDestination_setPrefix(self, prefix)
LogDestination_swigregister = _common.LogDestination_swigregister
LogDestination_swigregister(LogDestination)

class LogStream_ostream(LogDestination):
    __swig_setmethods__ = {}
    for _s in [LogDestination]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogStream_ostream, name, value)
    __swig_getmethods__ = {}
    for _s in [LogDestination]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LogStream_ostream, name)
    __repr__ = _swig_repr

    def __init__(self, destination):
        this = _common.new_LogStream_ostream(destination)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def log(self, message):
        return _common.LogStream_ostream_log(self, message)
    __swig_destroy__ = _common.delete_LogStream_ostream
    __del__ = lambda self: None
LogStream_ostream_swigregister = _common.LogStream_ostream_swigregister
LogStream_ostream_swigregister(LogStream_ostream)

class LogFile(LogDestination):
    __swig_setmethods__ = {}
    for _s in [LogDestination]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogFile, name, value)
    __swig_getmethods__ = {}
    for _s in [LogDestination]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, LogFile, name)
    __repr__ = _swig_repr

    def __init__(self, path):
        this = _common.new_LogFile(path)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def setMaxSize(self, newsize):
        return _common.LogFile_setMaxSize(self, newsize)

    def setBackups(self, newbackup):
        return _common.LogFile_setBackups(self, newbackup)

    def setReopen(self, newreopen):
        return _common.LogFile_setReopen(self, newreopen)

    def __nonzero__(self):
        return _common.LogFile___nonzero__(self)
    __bool__ = __nonzero__



    def log(self, message):
        return _common.LogFile_log(self, message)
    __swig_destroy__ = _common.delete_LogFile
    __del__ = lambda self: None
LogFile_swigregister = _common.LogFile_swigregister
LogFile_swigregister(LogFile)

class LoggerContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LoggerContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LoggerContext, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
LoggerContext_swigregister = _common.LoggerContext_swigregister
LoggerContext_swigregister(LoggerContext)

class Logger(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Logger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Logger, name)
    __repr__ = _swig_repr
    __swig_getmethods__["getRootLogger"] = lambda x: _common.Logger_getRootLogger
    if _newclass:
        getRootLogger = staticmethod(_common.Logger_getRootLogger)

    def __init__(self, *args):
        this = _common.new_Logger(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_Logger
    __del__ = lambda self: None

    def addDestination(self, destination):
        return _common.Logger_addDestination(self, destination)

    def addDestinations(self, destinations):
        return _common.Logger_addDestinations(self, destinations)

    def setDestinations(self, destinations):
        return _common.Logger_setDestinations(self, destinations)

    def getDestinations(self):
        return _common.Logger_getDestinations(self)

    def removeDestinations(self):
        return _common.Logger_removeDestinations(self)

    def deleteDestinations(self):
        return _common.Logger_deleteDestinations(self)

    def setThreshold(self, threshold):
        return _common.Logger_setThreshold(self, threshold)
    __swig_getmethods__["setThresholdForDomain"] = lambda x: _common.Logger_setThresholdForDomain
    if _newclass:
        setThresholdForDomain = staticmethod(_common.Logger_setThresholdForDomain)

    def getThreshold(self):
        return _common.Logger_getThreshold(self)

    def setThreadContext(self):
        return _common.Logger_setThreadContext(self)

    def msg(self, *args):
        return _common.Logger_msg(self, *args)
Logger_swigregister = _common.Logger_swigregister
Logger_swigregister(Logger)

def Logger_getRootLogger():
    return _common.Logger_getRootLogger()
Logger_getRootLogger = _common.Logger_getRootLogger

def Logger_setThresholdForDomain(*args):
    return _common.Logger_setThresholdForDomain(*args)
Logger_setThresholdForDomain = _common.Logger_setThresholdForDomain

class LogDestinationList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogDestinationList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogDestinationList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.LogDestinationList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.LogDestinationList___nonzero__(self)

    def __bool__(self):
        return _common.LogDestinationList___bool__(self)

    def __len__(self):
        return _common.LogDestinationList___len__(self)

    def __getslice__(self, i, j):
        return _common.LogDestinationList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.LogDestinationList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.LogDestinationList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.LogDestinationList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.LogDestinationList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.LogDestinationList___setitem__(self, *args)

    def pop(self):
        return _common.LogDestinationList_pop(self)

    def append(self, x):
        return _common.LogDestinationList_append(self, x)

    def empty(self):
        return _common.LogDestinationList_empty(self)

    def size(self):
        return _common.LogDestinationList_size(self)

    def swap(self, v):
        return _common.LogDestinationList_swap(self, v)

    def begin(self):
        return _common.LogDestinationList_begin(self)

    def end(self):
        return _common.LogDestinationList_end(self)

    def rbegin(self):
        return _common.LogDestinationList_rbegin(self)

    def rend(self):
        return _common.LogDestinationList_rend(self)

    def clear(self):
        return _common.LogDestinationList_clear(self)

    def get_allocator(self):
        return _common.LogDestinationList_get_allocator(self)

    def pop_back(self):
        return _common.LogDestinationList_pop_back(self)

    def erase(self, *args):
        return _common.LogDestinationList_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_LogDestinationList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.LogDestinationList_push_back(self, x)

    def front(self):
        return _common.LogDestinationList_front(self)

    def back(self):
        return _common.LogDestinationList_back(self)

    def assign(self, n, x):
        return _common.LogDestinationList_assign(self, n, x)

    def resize(self, *args):
        return _common.LogDestinationList_resize(self, *args)

    def insert(self, *args):
        return _common.LogDestinationList_insert(self, *args)

    def pop_front(self):
        return _common.LogDestinationList_pop_front(self)

    def push_front(self, x):
        return _common.LogDestinationList_push_front(self, x)

    def remove(self, x):
        return _common.LogDestinationList_remove(self, x)

    def unique(self):
        return _common.LogDestinationList_unique(self)

    def reverse(self):
        return _common.LogDestinationList_reverse(self)

    def sort(self):
        return _common.LogDestinationList_sort(self)

    def merge(self, x):
        return _common.LogDestinationList_merge(self, x)
    __swig_destroy__ = _common.delete_LogDestinationList
    __del__ = lambda self: None
LogDestinationList_swigregister = _common.LogDestinationList_swigregister
LogDestinationList_swigregister(LogDestinationList)


_common.MDSTime_swigconstant(_common)
MDSTime = _common.MDSTime

_common.ASCTime_swigconstant(_common)
ASCTime = _common.ASCTime

_common.UserTime_swigconstant(_common)
UserTime = _common.UserTime

_common.ISOTime_swigconstant(_common)
ISOTime = _common.ISOTime

_common.UTCTime_swigconstant(_common)
UTCTime = _common.UTCTime

_common.RFC1123Time_swigconstant(_common)
RFC1123Time = _common.RFC1123Time

_common.EpochTime_swigconstant(_common)
EpochTime = _common.EpochTime

_common.PeriodNanoseconds_swigconstant(_common)
PeriodNanoseconds = _common.PeriodNanoseconds

_common.PeriodMicroseconds_swigconstant(_common)
PeriodMicroseconds = _common.PeriodMicroseconds

_common.PeriodMiliseconds_swigconstant(_common)
PeriodMiliseconds = _common.PeriodMiliseconds

_common.PeriodSeconds_swigconstant(_common)
PeriodSeconds = _common.PeriodSeconds

_common.PeriodMinutes_swigconstant(_common)
PeriodMinutes = _common.PeriodMinutes

_common.PeriodHours_swigconstant(_common)
PeriodHours = _common.PeriodHours

_common.PeriodDays_swigconstant(_common)
PeriodDays = _common.PeriodDays

_common.PeriodWeeks_swigconstant(_common)
PeriodWeeks = _common.PeriodWeeks
class Period(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Period, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Period, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_Period(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def SetPeriod(self, *args):
        return _common.Period_SetPeriod(self, *args)

    def GetPeriod(self):
        return _common.Period_GetPeriod(self)

    def GetPeriodNanoseconds(self):
        return _common.Period_GetPeriodNanoseconds(self)

    def istr(self):
        return _common.Period_istr(self)

    def __str__(self):
        return _common.Period___str__(self)

    def __lt__(self, arg2):
        return _common.Period___lt__(self, arg2)

    def __gt__(self, arg2):
        return _common.Period___gt__(self, arg2)

    def __le__(self, arg2):
        return _common.Period___le__(self, arg2)

    def __ge__(self, arg2):
        return _common.Period___ge__(self, arg2)

    def __eq__(self, arg2):
        return _common.Period___eq__(self, arg2)

    def __ne__(self, arg2):
        return _common.Period___ne__(self, arg2)

    def __iadd__(self, arg2):
        return _common.Period___iadd__(self, arg2)
    __swig_destroy__ = _common.delete_Period
    __del__ = lambda self: None
Period_swigregister = _common.Period_swigregister
Period_swigregister(Period)

class Time(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Time, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Time, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_Time(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def SetTime(self, *args):
        return _common.Time_SetTime(self, *args)

    def GetTime(self):
        return _common.Time_GetTime(self)

    def GetTimeNanoseconds(self):
        return _common.Time_GetTimeNanoseconds(self)

    def __str__(self):
        return _common.Time___str__(self)

    def str(self, *args):
        return _common.Time_str(self, *args)
    __swig_getmethods__["SetFormat"] = lambda x: _common.Time_SetFormat
    if _newclass:
        SetFormat = staticmethod(_common.Time_SetFormat)
    __swig_getmethods__["GetFormat"] = lambda x: _common.Time_GetFormat
    if _newclass:
        GetFormat = staticmethod(_common.Time_GetFormat)

    def __lt__(self, arg2):
        return _common.Time___lt__(self, arg2)

    def __gt__(self, arg2):
        return _common.Time___gt__(self, arg2)

    def __le__(self, arg2):
        return _common.Time___le__(self, arg2)

    def __ge__(self, arg2):
        return _common.Time___ge__(self, arg2)

    def __eq__(self, arg2):
        return _common.Time___eq__(self, arg2)

    def __ne__(self, arg2):
        return _common.Time___ne__(self, arg2)

    def __add__(self, arg2):
        return _common.Time___add__(self, arg2)

    def __sub__(self, *args):
        return _common.Time___sub__(self, *args)
    YEAR = _common.Time_YEAR
    MONTH = _common.Time_MONTH
    WEEK = _common.Time_WEEK
    DAY = _common.Time_DAY
    HOUR = _common.Time_HOUR
    __swig_destroy__ = _common.delete_Time
    __del__ = lambda self: None
Time_swigregister = _common.Time_swigregister
Time_swigregister(Time)

def Time_SetFormat(arg2):
    return _common.Time_SetFormat(arg2)
Time_SetFormat = _common.Time_SetFormat

def Time_GetFormat():
    return _common.Time_GetFormat()
Time_GetFormat = _common.Time_GetFormat


def __lshift__(*args):
    return _common.__lshift__(*args)
__lshift__ = _common.__lshift__

def TimeStamp(*args):
    return _common.TimeStamp(*args)
TimeStamp = _common.TimeStamp

_common.RC_DEFAULT_PORT_swigconstant(_common)
RC_DEFAULT_PORT = _common.RC_DEFAULT_PORT

_common.HTTP_DEFAULT_PORT_swigconstant(_common)
HTTP_DEFAULT_PORT = _common.HTTP_DEFAULT_PORT

_common.HTTPS_DEFAULT_PORT_swigconstant(_common)
HTTPS_DEFAULT_PORT = _common.HTTPS_DEFAULT_PORT

_common.HTTPG_DEFAULT_PORT_swigconstant(_common)
HTTPG_DEFAULT_PORT = _common.HTTPG_DEFAULT_PORT

_common.LDAP_DEFAULT_PORT_swigconstant(_common)
LDAP_DEFAULT_PORT = _common.LDAP_DEFAULT_PORT

_common.FTP_DEFAULT_PORT_swigconstant(_common)
FTP_DEFAULT_PORT = _common.FTP_DEFAULT_PORT

_common.GSIFTP_DEFAULT_PORT_swigconstant(_common)
GSIFTP_DEFAULT_PORT = _common.GSIFTP_DEFAULT_PORT

_common.LFC_DEFAULT_PORT_swigconstant(_common)
LFC_DEFAULT_PORT = _common.LFC_DEFAULT_PORT

_common.XROOTD_DEFAULT_PORT_swigconstant(_common)
XROOTD_DEFAULT_PORT = _common.XROOTD_DEFAULT_PORT
class URL(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URL, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_URL(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_URL
    __del__ = lambda self: None
    base = _common.URL_base
    onelevel = _common.URL_onelevel
    subtree = _common.URL_subtree

    def Protocol(self):
        return _common.URL_Protocol(self)

    def ChangeProtocol(self, newprot):
        return _common.URL_ChangeProtocol(self, newprot)

    def Username(self):
        return _common.URL_Username(self)

    def Passwd(self):
        return _common.URL_Passwd(self)

    def Host(self):
        return _common.URL_Host(self)

    def ChangeHost(self, newhost):
        return _common.URL_ChangeHost(self, newhost)

    def Port(self):
        return _common.URL_Port(self)

    def ChangePort(self, newport):
        return _common.URL_ChangePort(self, newport)

    def Path(self):
        return _common.URL_Path(self)

    def FullPath(self):
        return _common.URL_FullPath(self)

    def FullPathURIEncoded(self):
        return _common.URL_FullPathURIEncoded(self)

    def ChangePath(self, newpath):
        return _common.URL_ChangePath(self, newpath)

    def ChangeFullPath(self, newpath, encoded=False):
        return _common.URL_ChangeFullPath(self, newpath, encoded)

    def HTTPOptions(self):
        return _common.URL_HTTPOptions(self)

    def HTTPOption(self, *args):
        return _common.URL_HTTPOption(self, *args)

    def AddHTTPOption(self, option, value, overwrite=True):
        return _common.URL_AddHTTPOption(self, option, value, overwrite)

    def RemoveHTTPOption(self, option):
        return _common.URL_RemoveHTTPOption(self, option)

    def LDAPAttributes(self):
        return _common.URL_LDAPAttributes(self)

    def AddLDAPAttribute(self, attribute):
        return _common.URL_AddLDAPAttribute(self, attribute)

    def LDAPScope(self):
        return _common.URL_LDAPScope(self)

    def ChangeLDAPScope(self, newscope):
        return _common.URL_ChangeLDAPScope(self, newscope)

    def LDAPFilter(self):
        return _common.URL_LDAPFilter(self)

    def ChangeLDAPFilter(self, newfilter):
        return _common.URL_ChangeLDAPFilter(self, newfilter)

    def Options(self):
        return _common.URL_Options(self)

    def Option(self, *args):
        return _common.URL_Option(self, *args)

    def MetaDataOptions(self):
        return _common.URL_MetaDataOptions(self)

    def MetaDataOption(self, *args):
        return _common.URL_MetaDataOption(self, *args)

    def AddOption(self, *args):
        return _common.URL_AddOption(self, *args)

    def AddMetaDataOption(self, option, value, overwrite=True):
        return _common.URL_AddMetaDataOption(self, option, value, overwrite)

    def AddLocation(self, location):
        return _common.URL_AddLocation(self, location)

    def Locations(self):
        return _common.URL_Locations(self)

    def CommonLocOptions(self):
        return _common.URL_CommonLocOptions(self)

    def CommonLocOption(self, *args):
        return _common.URL_CommonLocOption(self, *args)

    def RemoveOption(self, option):
        return _common.URL_RemoveOption(self, option)

    def RemoveMetaDataOption(self, option):
        return _common.URL_RemoveMetaDataOption(self, option)

    def str(self, encode=False):
        return _common.URL_str(self, encode)

    def plainstr(self, encode=False):
        return _common.URL_plainstr(self, encode)

    def fullstr(self, encode=False):
        return _common.URL_fullstr(self, encode)

    def ConnectionURL(self):
        return _common.URL_ConnectionURL(self)

    def __lt__(self, url):
        return _common.URL___lt__(self, url)

    def __eq__(self, url):
        return _common.URL___eq__(self, url)

    def __nonzero__(self):
        return _common.URL___nonzero__(self)
    __bool__ = __nonzero__



    def StringMatches(self, str):
        return _common.URL_StringMatches(self, str)

    def ParseOptions(self, optstring, separator, encoded=False):
        return _common.URL_ParseOptions(self, optstring, separator, encoded)
    __swig_getmethods__["OptionString"] = lambda x: _common.URL_OptionString
    if _newclass:
        OptionString = staticmethod(_common.URL_OptionString)
    __swig_getmethods__["URIEncode"] = lambda x: _common.URL_URIEncode
    if _newclass:
        URIEncode = staticmethod(_common.URL_URIEncode)
    __swig_getmethods__["URIDecode"] = lambda x: _common.URL_URIDecode
    if _newclass:
        URIDecode = staticmethod(_common.URL_URIDecode)
URL_swigregister = _common.URL_swigregister
URL_swigregister(URL)

def URL_OptionString(options, separator, encode=False):
    return _common.URL_OptionString(options, separator, encode)
URL_OptionString = _common.URL_OptionString

def URL_URIEncode(str):
    return _common.URL_URIEncode(str)
URL_URIEncode = _common.URL_URIEncode

def URL_URIDecode(*args):
    return _common.URL_URIDecode(*args)
URL_URIDecode = _common.URL_URIDecode

class URLLocation(URL):
    __swig_setmethods__ = {}
    for _s in [URL]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLLocation, name, value)
    __swig_getmethods__ = {}
    for _s in [URL]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, URLLocation, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_URLLocation(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_URLLocation
    __del__ = lambda self: None

    def Name(self):
        return _common.URLLocation_Name(self)

    def str(self, encode=False):
        return _common.URLLocation_str(self, encode)

    def fullstr(self, encode=False):
        return _common.URLLocation_fullstr(self, encode)
URLLocation_swigregister = _common.URLLocation_swigregister
URLLocation_swigregister(URLLocation)

class PathIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PathIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PathIterator, name)
    __repr__ = _swig_repr

    def __init__(self, path, end=False):
        this = _common.new_PathIterator(path, end)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_PathIterator
    __del__ = lambda self: None

    def __nonzero__(self):
        return _common.PathIterator___nonzero__(self)
    __bool__ = __nonzero__



    def __ref__(self):
        return _common.PathIterator___ref__(self)

    def Rest(self):
        return _common.PathIterator_Rest(self)
PathIterator_swigregister = _common.PathIterator_swigregister
PathIterator_swigregister(PathIterator)


def ReadURLList(urllist):
    return _common.ReadURLList(urllist)
ReadURLList = _common.ReadURLList
class URLList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.URLList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.URLList___nonzero__(self)

    def __bool__(self):
        return _common.URLList___bool__(self)

    def __len__(self):
        return _common.URLList___len__(self)

    def __getslice__(self, i, j):
        return _common.URLList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.URLList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.URLList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.URLList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.URLList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.URLList___setitem__(self, *args)

    def pop(self):
        return _common.URLList_pop(self)

    def append(self, x):
        return _common.URLList_append(self, x)

    def empty(self):
        return _common.URLList_empty(self)

    def size(self):
        return _common.URLList_size(self)

    def swap(self, v):
        return _common.URLList_swap(self, v)

    def begin(self):
        return _common.URLList_begin(self)

    def end(self):
        return _common.URLList_end(self)

    def rbegin(self):
        return _common.URLList_rbegin(self)

    def rend(self):
        return _common.URLList_rend(self)

    def clear(self):
        return _common.URLList_clear(self)

    def get_allocator(self):
        return _common.URLList_get_allocator(self)

    def pop_back(self):
        return _common.URLList_pop_back(self)

    def erase(self, *args):
        return _common.URLList_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_URLList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.URLList_push_back(self, x)

    def front(self):
        return _common.URLList_front(self)

    def back(self):
        return _common.URLList_back(self)

    def assign(self, n, x):
        return _common.URLList_assign(self, n, x)

    def resize(self, *args):
        return _common.URLList_resize(self, *args)

    def insert(self, *args):
        return _common.URLList_insert(self, *args)

    def pop_front(self):
        return _common.URLList_pop_front(self)

    def push_front(self, x):
        return _common.URLList_push_front(self, x)

    def reverse(self):
        return _common.URLList_reverse(self)
    __swig_destroy__ = _common.delete_URLList
    __del__ = lambda self: None
URLList_swigregister = _common.URLList_swigregister
URLList_swigregister(URLList)

class URLVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLVector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.URLVector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.URLVector___nonzero__(self)

    def __bool__(self):
        return _common.URLVector___bool__(self)

    def __len__(self):
        return _common.URLVector___len__(self)

    def __getslice__(self, i, j):
        return _common.URLVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.URLVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.URLVector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.URLVector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.URLVector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.URLVector___setitem__(self, *args)

    def pop(self):
        return _common.URLVector_pop(self)

    def append(self, x):
        return _common.URLVector_append(self, x)

    def empty(self):
        return _common.URLVector_empty(self)

    def size(self):
        return _common.URLVector_size(self)

    def swap(self, v):
        return _common.URLVector_swap(self, v)

    def begin(self):
        return _common.URLVector_begin(self)

    def end(self):
        return _common.URLVector_end(self)

    def rbegin(self):
        return _common.URLVector_rbegin(self)

    def rend(self):
        return _common.URLVector_rend(self)

    def clear(self):
        return _common.URLVector_clear(self)

    def get_allocator(self):
        return _common.URLVector_get_allocator(self)

    def pop_back(self):
        return _common.URLVector_pop_back(self)

    def erase(self, *args):
        return _common.URLVector_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_URLVector(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.URLVector_push_back(self, x)

    def front(self):
        return _common.URLVector_front(self)

    def back(self):
        return _common.URLVector_back(self)

    def assign(self, n, x):
        return _common.URLVector_assign(self, n, x)

    def resize(self, *args):
        return _common.URLVector_resize(self, *args)

    def insert(self, *args):
        return _common.URLVector_insert(self, *args)

    def reserve(self, n):
        return _common.URLVector_reserve(self, n)

    def capacity(self):
        return _common.URLVector_capacity(self)
    __swig_destroy__ = _common.delete_URLVector
    __del__ = lambda self: None
URLVector_swigregister = _common.URLVector_swigregister
URLVector_swigregister(URLVector)

class URLListMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLListMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLListMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.URLListMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.URLListMap___nonzero__(self)

    def __bool__(self):
        return _common.URLListMap___bool__(self)

    def __len__(self):
        return _common.URLListMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _common.URLListMap___getitem__(self, key)

    def __delitem__(self, key):
        return _common.URLListMap___delitem__(self, key)

    def has_key(self, key):
        return _common.URLListMap_has_key(self, key)

    def keys(self):
        return _common.URLListMap_keys(self)

    def values(self):
        return _common.URLListMap_values(self)

    def items(self):
        return _common.URLListMap_items(self)

    def __contains__(self, key):
        return _common.URLListMap___contains__(self, key)

    def key_iterator(self):
        return _common.URLListMap_key_iterator(self)

    def value_iterator(self):
        return _common.URLListMap_value_iterator(self)

    def __setitem__(self, *args):
        return _common.URLListMap___setitem__(self, *args)

    def asdict(self):
        return _common.URLListMap_asdict(self)

    def __init__(self, *args):
        this = _common.new_URLListMap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _common.URLListMap_empty(self)

    def size(self):
        return _common.URLListMap_size(self)

    def swap(self, v):
        return _common.URLListMap_swap(self, v)

    def begin(self):
        return _common.URLListMap_begin(self)

    def end(self):
        return _common.URLListMap_end(self)

    def rbegin(self):
        return _common.URLListMap_rbegin(self)

    def rend(self):
        return _common.URLListMap_rend(self)

    def clear(self):
        return _common.URLListMap_clear(self)

    def get_allocator(self):
        return _common.URLListMap_get_allocator(self)

    def count(self, x):
        return _common.URLListMap_count(self, x)

    def erase(self, *args):
        return _common.URLListMap_erase(self, *args)

    def find(self, x):
        return _common.URLListMap_find(self, x)

    def lower_bound(self, x):
        return _common.URLListMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _common.URLListMap_upper_bound(self, x)
    __swig_destroy__ = _common.delete_URLListMap
    __del__ = lambda self: None
URLListMap_swigregister = _common.URLListMap_swigregister
URLListMap_swigregister(URLListMap)

class URLLocationList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLLocationList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLLocationList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.URLLocationList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.URLLocationList___nonzero__(self)

    def __bool__(self):
        return _common.URLLocationList___bool__(self)

    def __len__(self):
        return _common.URLLocationList___len__(self)

    def __getslice__(self, i, j):
        return _common.URLLocationList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.URLLocationList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.URLLocationList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.URLLocationList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.URLLocationList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.URLLocationList___setitem__(self, *args)

    def pop(self):
        return _common.URLLocationList_pop(self)

    def append(self, x):
        return _common.URLLocationList_append(self, x)

    def empty(self):
        return _common.URLLocationList_empty(self)

    def size(self):
        return _common.URLLocationList_size(self)

    def swap(self, v):
        return _common.URLLocationList_swap(self, v)

    def begin(self):
        return _common.URLLocationList_begin(self)

    def end(self):
        return _common.URLLocationList_end(self)

    def rbegin(self):
        return _common.URLLocationList_rbegin(self)

    def rend(self):
        return _common.URLLocationList_rend(self)

    def clear(self):
        return _common.URLLocationList_clear(self)

    def get_allocator(self):
        return _common.URLLocationList_get_allocator(self)

    def pop_back(self):
        return _common.URLLocationList_pop_back(self)

    def erase(self, *args):
        return _common.URLLocationList_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_URLLocationList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.URLLocationList_push_back(self, x)

    def front(self):
        return _common.URLLocationList_front(self)

    def back(self):
        return _common.URLLocationList_back(self)

    def assign(self, n, x):
        return _common.URLLocationList_assign(self, n, x)

    def resize(self, *args):
        return _common.URLLocationList_resize(self, *args)

    def insert(self, *args):
        return _common.URLLocationList_insert(self, *args)

    def pop_front(self):
        return _common.URLLocationList_pop_front(self)

    def push_front(self, x):
        return _common.URLLocationList_push_front(self, x)

    def reverse(self):
        return _common.URLLocationList_reverse(self)
    __swig_destroy__ = _common.delete_URLLocationList
    __del__ = lambda self: None
URLLocationList_swigregister = _common.URLLocationList_swigregister
URLLocationList_swigregister(URLLocationList)

class User(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, User, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, User, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_User(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __nonzero__(self):
        return _common.User___nonzero__(self)
    __bool__ = __nonzero__



    def Name(self):
        return _common.User_Name(self)

    def Home(self):
        return _common.User_Home(self)

    def get_uid(self):
        return _common.User_get_uid(self)

    def get_gid(self):
        return _common.User_get_gid(self)

    def __eq__(self, n):
        return _common.User___eq__(self, n)

    def check_file_access(self, path, flags):
        return _common.User_check_file_access(self, path, flags)

    def SwitchUser(self):
        return _common.User_SwitchUser(self)
    __swig_destroy__ = _common.delete_User
    __del__ = lambda self: None
User_swigregister = _common.User_swigregister
User_swigregister(User)

class UserSwitch(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UserSwitch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UserSwitch, name)
    __repr__ = _swig_repr

    def __init__(self, uid, gid):
        this = _common.new_UserSwitch(uid, gid)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_UserSwitch
    __del__ = lambda self: None

    def __nonzero__(self):
        return _common.UserSwitch___nonzero__(self)
    __bool__ = __nonzero__


UserSwitch_swigregister = _common.UserSwitch_swigregister
UserSwitch_swigregister(UserSwitch)

class ConfigEndpointList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigEndpointList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigEndpointList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.ConfigEndpointList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.ConfigEndpointList___nonzero__(self)

    def __bool__(self):
        return _common.ConfigEndpointList___bool__(self)

    def __len__(self):
        return _common.ConfigEndpointList___len__(self)

    def __getslice__(self, i, j):
        return _common.ConfigEndpointList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.ConfigEndpointList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.ConfigEndpointList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.ConfigEndpointList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.ConfigEndpointList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.ConfigEndpointList___setitem__(self, *args)

    def pop(self):
        return _common.ConfigEndpointList_pop(self)

    def append(self, x):
        return _common.ConfigEndpointList_append(self, x)

    def empty(self):
        return _common.ConfigEndpointList_empty(self)

    def size(self):
        return _common.ConfigEndpointList_size(self)

    def swap(self, v):
        return _common.ConfigEndpointList_swap(self, v)

    def begin(self):
        return _common.ConfigEndpointList_begin(self)

    def end(self):
        return _common.ConfigEndpointList_end(self)

    def rbegin(self):
        return _common.ConfigEndpointList_rbegin(self)

    def rend(self):
        return _common.ConfigEndpointList_rend(self)

    def clear(self):
        return _common.ConfigEndpointList_clear(self)

    def get_allocator(self):
        return _common.ConfigEndpointList_get_allocator(self)

    def pop_back(self):
        return _common.ConfigEndpointList_pop_back(self)

    def erase(self, *args):
        return _common.ConfigEndpointList_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_ConfigEndpointList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.ConfigEndpointList_push_back(self, x)

    def front(self):
        return _common.ConfigEndpointList_front(self)

    def back(self):
        return _common.ConfigEndpointList_back(self)

    def assign(self, n, x):
        return _common.ConfigEndpointList_assign(self, n, x)

    def resize(self, *args):
        return _common.ConfigEndpointList_resize(self, *args)

    def insert(self, *args):
        return _common.ConfigEndpointList_insert(self, *args)

    def pop_front(self):
        return _common.ConfigEndpointList_pop_front(self)

    def push_front(self, x):
        return _common.ConfigEndpointList_push_front(self, x)

    def reverse(self):
        return _common.ConfigEndpointList_reverse(self)
    __swig_destroy__ = _common.delete_ConfigEndpointList
    __del__ = lambda self: None
ConfigEndpointList_swigregister = _common.ConfigEndpointList_swigregister
ConfigEndpointList_swigregister(ConfigEndpointList)


_common.COMPUTING_swigconstant(_common)
COMPUTING = _common.COMPUTING

_common.INDEX_swigconstant(_common)
INDEX = _common.INDEX
class ConfigEndpoint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigEndpoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigEndpoint, name)
    __repr__ = _swig_repr
    REGISTRY = _common.ConfigEndpoint_REGISTRY
    COMPUTINGINFO = _common.ConfigEndpoint_COMPUTINGINFO
    ANY = _common.ConfigEndpoint_ANY

    def __init__(self, *args):
        this = _common.new_ConfigEndpoint(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_setmethods__["type"] = _common.ConfigEndpoint_type_set
    __swig_getmethods__["type"] = _common.ConfigEndpoint_type_get
    if _newclass:
        type = _swig_property(_common.ConfigEndpoint_type_get, _common.ConfigEndpoint_type_set)
    __swig_setmethods__["URLString"] = _common.ConfigEndpoint_URLString_set
    __swig_getmethods__["URLString"] = _common.ConfigEndpoint_URLString_get
    if _newclass:
        URLString = _swig_property(_common.ConfigEndpoint_URLString_get, _common.ConfigEndpoint_URLString_set)
    __swig_setmethods__["InterfaceName"] = _common.ConfigEndpoint_InterfaceName_set
    __swig_getmethods__["InterfaceName"] = _common.ConfigEndpoint_InterfaceName_get
    if _newclass:
        InterfaceName = _swig_property(_common.ConfigEndpoint_InterfaceName_get, _common.ConfigEndpoint_InterfaceName_set)
    __swig_setmethods__["RequestedSubmissionInterfaceName"] = _common.ConfigEndpoint_RequestedSubmissionInterfaceName_set
    __swig_getmethods__["RequestedSubmissionInterfaceName"] = _common.ConfigEndpoint_RequestedSubmissionInterfaceName_get
    if _newclass:
        RequestedSubmissionInterfaceName = _swig_property(_common.ConfigEndpoint_RequestedSubmissionInterfaceName_get, _common.ConfigEndpoint_RequestedSubmissionInterfaceName_set)

    def __nonzero__(self):
        return _common.ConfigEndpoint___nonzero__(self)
    __bool__ = __nonzero__



    def __eq__(self, c):
        return _common.ConfigEndpoint___eq__(self, c)
    __swig_destroy__ = _common.delete_ConfigEndpoint
    __del__ = lambda self: None
ConfigEndpoint_swigregister = _common.ConfigEndpoint_swigregister
ConfigEndpoint_swigregister(ConfigEndpoint)


def tostring(st):
    return _common.tostring(st)
tostring = _common.tostring
class initializeCredentialsType(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, initializeCredentialsType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, initializeCredentialsType, name)
    __repr__ = _swig_repr
    SkipCredentials = _common.initializeCredentialsType_SkipCredentials
    NotTryCredentials = _common.initializeCredentialsType_NotTryCredentials
    TryCredentials = _common.initializeCredentialsType_TryCredentials
    RequireCredentials = _common.initializeCredentialsType_RequireCredentials
    SkipCANotTryCredentials = _common.initializeCredentialsType_SkipCANotTryCredentials
    SkipCATryCredentials = _common.initializeCredentialsType_SkipCATryCredentials
    SkipCARequireCredentials = _common.initializeCredentialsType_SkipCARequireCredentials

    def __init__(self, *args):
        this = _common.new_initializeCredentialsType(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __eq__(self, v):
        return _common.initializeCredentialsType___eq__(self, v)

    def __ne__(self, v):
        return _common.initializeCredentialsType___ne__(self, v)

    def toValue(self):
        return _common.initializeCredentialsType_toValue(self)
    __swig_destroy__ = _common.delete_initializeCredentialsType
    __del__ = lambda self: None
initializeCredentialsType_swigregister = _common.initializeCredentialsType_swigregister
initializeCredentialsType_swigregister(initializeCredentialsType)

class UserConfig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UserConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UserConfig, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_UserConfig(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_UserConfig
    __del__ = lambda self: None

    def InitializeCredentials(self, initializeCredentials):
        return _common.UserConfig_InitializeCredentials(self, initializeCredentials)

    def CredentialsFound(self):
        return _common.UserConfig_CredentialsFound(self)

    def LoadConfigurationFile(self, conffile, ignoreJobListFile=True):
        return _common.UserConfig_LoadConfigurationFile(self, conffile, ignoreJobListFile)

    def SaveToFile(self, filename):
        return _common.UserConfig_SaveToFile(self, filename)

    def ApplyToConfig(self, ccfg):
        return _common.UserConfig_ApplyToConfig(self, ccfg)

    def __nonzero__(self):
        return _common.UserConfig___nonzero__(self)
    __bool__ = __nonzero__



    def JobListFile(self, *args):
        return _common.UserConfig_JobListFile(self, *args)

    def JobListType(self, *args):
        return _common.UserConfig_JobListType(self, *args)

    def Timeout(self, *args):
        return _common.UserConfig_Timeout(self, *args)

    def Verbosity(self, *args):
        return _common.UserConfig_Verbosity(self, *args)

    def Broker(self, *args):
        return _common.UserConfig_Broker(self, *args)

    def VOMSESPath(self, *args):
        return _common.UserConfig_VOMSESPath(self, *args)

    def UserName(self, *args):
        return _common.UserConfig_UserName(self, *args)

    def Password(self, *args):
        return _common.UserConfig_Password(self, *args)

    def CredentialString(self, *args):
        return _common.UserConfig_CredentialString(self, *args)

    def ProxyPath(self, *args):
        return _common.UserConfig_ProxyPath(self, *args)

    def CertificatePath(self, *args):
        return _common.UserConfig_CertificatePath(self, *args)

    def KeyPath(self, *args):
        return _common.UserConfig_KeyPath(self, *args)

    def KeyPassword(self, *args):
        return _common.UserConfig_KeyPassword(self, *args)

    def KeySize(self, *args):
        return _common.UserConfig_KeySize(self, *args)

    def CACertificatePath(self, *args):
        return _common.UserConfig_CACertificatePath(self, *args)

    def CACertificatesDirectory(self, *args):
        return _common.UserConfig_CACertificatesDirectory(self, *args)

    def CertificateLifeTime(self, *args):
        return _common.UserConfig_CertificateLifeTime(self, *args)

    def SLCS(self, *args):
        return _common.UserConfig_SLCS(self, *args)

    def StoreDirectory(self, *args):
        return _common.UserConfig_StoreDirectory(self, *args)

    def JobDownloadDirectory(self, *args):
        return _common.UserConfig_JobDownloadDirectory(self, *args)

    def IdPName(self, *args):
        return _common.UserConfig_IdPName(self, *args)

    def OverlayFile(self, *args):
        return _common.UserConfig_OverlayFile(self, *args)

    def UtilsDirPath(self, *args):
        return _common.UserConfig_UtilsDirPath(self, *args)

    def SetUser(self, u):
        return _common.UserConfig_SetUser(self, u)

    def GetUser(self):
        return _common.UserConfig_GetUser(self)

    def InfoInterface(self, *args):
        return _common.UserConfig_InfoInterface(self, *args)

    def SubmissionInterface(self, *args):
        return _common.UserConfig_SubmissionInterface(self, *args)

    def RejectDiscoveryURLs(self):
        return _common.UserConfig_RejectDiscoveryURLs(self)

    def AddRejectDiscoveryURLs(self, urls):
        return _common.UserConfig_AddRejectDiscoveryURLs(self, urls)

    def ClearRejectDiscoveryURLs(self):
        return _common.UserConfig_ClearRejectDiscoveryURLs(self)

    def RejectManagementURLs(self):
        return _common.UserConfig_RejectManagementURLs(self)

    def GetService(self, alias):
        return _common.UserConfig_GetService(self, alias)

    def GetServicesInGroup(self, *args):
        return _common.UserConfig_GetServicesInGroup(self, *args)

    def GetDefaultServices(self, *args):
        return _common.UserConfig_GetDefaultServices(self, *args)

    def GetServices(self, *args):
        return _common.UserConfig_GetServices(self, *args)

    def GetAllConfiguredServices(self):
        return _common.UserConfig_GetAllConfiguredServices(self)
    DEFAULT_TIMEOUT = _common.UserConfig_DEFAULT_TIMEOUT
UserConfig_swigregister = _common.UserConfig_swigregister
UserConfig_swigregister(UserConfig)
UserConfig.ARCUSERDIRECTORY = _common.cvar.UserConfig_ARCUSERDIRECTORY
UserConfig.SYSCONFIG = _common.cvar.UserConfig_SYSCONFIG
UserConfig.SYSCONFIGARCLOC = _common.cvar.UserConfig_SYSCONFIGARCLOC
UserConfig.DEFAULTCONFIG = _common.cvar.UserConfig_DEFAULTCONFIG
UserConfig.EXAMPLECONFIG = _common.cvar.UserConfig_EXAMPLECONFIG
UserConfig.JOBLISTFILE = _common.cvar.UserConfig_JOBLISTFILE
UserConfig.DEFAULT_BROKER = _common.cvar.UserConfig_DEFAULT_BROKER

class CertEnvLocker(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CertEnvLocker, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CertEnvLocker, name)
    __repr__ = _swig_repr

    def __init__(self, cfg):
        this = _common.new_CertEnvLocker(cfg)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_CertEnvLocker
    __del__ = lambda self: None
CertEnvLocker_swigregister = _common.CertEnvLocker_swigregister
CertEnvLocker_swigregister(CertEnvLocker)

class ConfigEndpointMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigEndpointMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigEndpointMap, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.ConfigEndpointMap_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.ConfigEndpointMap___nonzero__(self)

    def __bool__(self):
        return _common.ConfigEndpointMap___bool__(self)

    def __len__(self):
        return _common.ConfigEndpointMap___len__(self)
    def __iter__(self):
        return self.key_iterator()
    def iterkeys(self):
        return self.key_iterator()
    def itervalues(self):
        return self.value_iterator()
    def iteritems(self):
        return self.iterator()

    def __getitem__(self, key):
        return _common.ConfigEndpointMap___getitem__(self, key)

    def __delitem__(self, key):
        return _common.ConfigEndpointMap___delitem__(self, key)

    def has_key(self, key):
        return _common.ConfigEndpointMap_has_key(self, key)

    def keys(self):
        return _common.ConfigEndpointMap_keys(self)

    def values(self):
        return _common.ConfigEndpointMap_values(self)

    def items(self):
        return _common.ConfigEndpointMap_items(self)

    def __contains__(self, key):
        return _common.ConfigEndpointMap___contains__(self, key)

    def key_iterator(self):
        return _common.ConfigEndpointMap_key_iterator(self)

    def value_iterator(self):
        return _common.ConfigEndpointMap_value_iterator(self)

    def __setitem__(self, *args):
        return _common.ConfigEndpointMap___setitem__(self, *args)

    def asdict(self):
        return _common.ConfigEndpointMap_asdict(self)

    def __init__(self, *args):
        this = _common.new_ConfigEndpointMap(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def empty(self):
        return _common.ConfigEndpointMap_empty(self)

    def size(self):
        return _common.ConfigEndpointMap_size(self)

    def swap(self, v):
        return _common.ConfigEndpointMap_swap(self, v)

    def begin(self):
        return _common.ConfigEndpointMap_begin(self)

    def end(self):
        return _common.ConfigEndpointMap_end(self)

    def rbegin(self):
        return _common.ConfigEndpointMap_rbegin(self)

    def rend(self):
        return _common.ConfigEndpointMap_rend(self)

    def clear(self):
        return _common.ConfigEndpointMap_clear(self)

    def get_allocator(self):
        return _common.ConfigEndpointMap_get_allocator(self)

    def count(self, x):
        return _common.ConfigEndpointMap_count(self, x)

    def erase(self, *args):
        return _common.ConfigEndpointMap_erase(self, *args)

    def find(self, x):
        return _common.ConfigEndpointMap_find(self, x)

    def lower_bound(self, x):
        return _common.ConfigEndpointMap_lower_bound(self, x)

    def upper_bound(self, x):
        return _common.ConfigEndpointMap_upper_bound(self, x)
    __swig_destroy__ = _common.delete_ConfigEndpointMap
    __del__ = lambda self: None
ConfigEndpointMap_swigregister = _common.ConfigEndpointMap_swigregister
ConfigEndpointMap_swigregister(ConfigEndpointMap)


def GUID(guid):
    return _common.GUID(guid)
GUID = _common.GUID

def UUID():
    return _common.UUID()
UUID = _common.UUID
class CheckSum(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CheckSum, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CheckSum, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_CheckSum
    __del__ = lambda self: None

    def start(self):
        return _common.CheckSum_start(self)

    def add(self, buf, len):
        return _common.CheckSum_add(self, buf, len)

    def end(self):
        return _common.CheckSum_end(self)

    def result(self, res, len):
        return _common.CheckSum_result(self, res, len)

    def _print(self, buf, len):
        return _common.CheckSum__print(self, buf, len)

    def scan(self, buf):
        return _common.CheckSum_scan(self, buf)

    def __nonzero__(self):
        return _common.CheckSum___nonzero__(self)
    __bool__ = __nonzero__


CheckSum_swigregister = _common.CheckSum_swigregister
CheckSum_swigregister(CheckSum)

class CRC32Sum(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CRC32Sum, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CRC32Sum, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_CRC32Sum()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_CRC32Sum
    __del__ = lambda self: None

    def start(self):
        return _common.CRC32Sum_start(self)

    def add(self, buf, len):
        return _common.CRC32Sum_add(self, buf, len)

    def end(self):
        return _common.CRC32Sum_end(self)

    def result(self, res, len):
        return _common.CRC32Sum_result(self, res, len)

    def _print(self, buf, len):
        return _common.CRC32Sum__print(self, buf, len)

    def scan(self, buf):
        return _common.CRC32Sum_scan(self, buf)

    def __nonzero__(self):
        return _common.CRC32Sum___nonzero__(self)
    __bool__ = __nonzero__



    def crc(self):
        return _common.CRC32Sum_crc(self)
CRC32Sum_swigregister = _common.CRC32Sum_swigregister
CRC32Sum_swigregister(CRC32Sum)

class MD5Sum(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MD5Sum, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, MD5Sum, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_MD5Sum()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def start(self):
        return _common.MD5Sum_start(self)

    def add(self, buf, len):
        return _common.MD5Sum_add(self, buf, len)

    def end(self):
        return _common.MD5Sum_end(self)

    def result(self, res, len):
        return _common.MD5Sum_result(self, res, len)

    def _print(self, buf, len):
        return _common.MD5Sum__print(self, buf, len)

    def scan(self, buf):
        return _common.MD5Sum_scan(self, buf)

    def __nonzero__(self):
        return _common.MD5Sum___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _common.delete_MD5Sum
    __del__ = lambda self: None
MD5Sum_swigregister = _common.MD5Sum_swigregister
MD5Sum_swigregister(MD5Sum)

class Adler32Sum(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Adler32Sum, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Adler32Sum, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_Adler32Sum()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def start(self):
        return _common.Adler32Sum_start(self)

    def add(self, buf, len):
        return _common.Adler32Sum_add(self, buf, len)

    def end(self):
        return _common.Adler32Sum_end(self)

    def result(self, res, len):
        return _common.Adler32Sum_result(self, res, len)

    def _print(self, buf, len):
        return _common.Adler32Sum__print(self, buf, len)

    def scan(self, arg2):
        return _common.Adler32Sum_scan(self, arg2)

    def __nonzero__(self):
        return _common.Adler32Sum___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _common.delete_Adler32Sum
    __del__ = lambda self: None
Adler32Sum_swigregister = _common.Adler32Sum_swigregister
Adler32Sum_swigregister(Adler32Sum)

class CheckSumAny(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CheckSumAny, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, CheckSumAny, name)
    __repr__ = _swig_repr
    none = _common.CheckSumAny_none
    unknown = _common.CheckSumAny_unknown
    undefined = _common.CheckSumAny_undefined
    cksum = _common.CheckSumAny_cksum
    md5 = _common.CheckSumAny_md5
    adler32 = _common.CheckSumAny_adler32

    def __init__(self, *args):
        this = _common.new_CheckSumAny(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_CheckSumAny
    __del__ = lambda self: None

    def start(self):
        return _common.CheckSumAny_start(self)

    def add(self, buf, len):
        return _common.CheckSumAny_add(self, buf, len)

    def end(self):
        return _common.CheckSumAny_end(self)

    def result(self, res, len):
        return _common.CheckSumAny_result(self, res, len)

    def _print(self, buf, len):
        return _common.CheckSumAny__print(self, buf, len)

    def scan(self, buf):
        return _common.CheckSumAny_scan(self, buf)

    def __nonzero__(self):
        return _common.CheckSumAny___nonzero__(self)
    __bool__ = __nonzero__



    def active(self):
        return _common.CheckSumAny_active(self)

    def Type(self, *args):
        return _common.CheckSumAny_Type(self, *args)

    def __eq__(self, *args):
        return _common.CheckSumAny___eq__(self, *args)
    __swig_getmethods__["FileChecksum"] = lambda x: _common.CheckSumAny_FileChecksum
    if _newclass:
        FileChecksum = staticmethod(_common.CheckSumAny_FileChecksum)
CheckSumAny_swigregister = _common.CheckSumAny_swigregister
CheckSumAny_swigregister(CheckSumAny)

def CheckSumAny_FileChecksum(*args):
    return _common.CheckSumAny_FileChecksum(*args)
CheckSumAny_FileChecksum = _common.CheckSumAny_FileChecksum


def CreateThreadFunction(func, arg, count=None):
    return _common.CreateThreadFunction(func, arg, count)
CreateThreadFunction = _common.CreateThreadFunction
class ThreadDataItem(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadDataItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadDataItem, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _common.new_ThreadDataItem(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def Attach(self, *args):
        return _common.ThreadDataItem_Attach(self, *args)
    __swig_getmethods__["Get"] = lambda x: _common.ThreadDataItem_Get
    if _newclass:
        Get = staticmethod(_common.ThreadDataItem_Get)

    def Dup(self):
        return _common.ThreadDataItem_Dup(self)
ThreadDataItem_swigregister = _common.ThreadDataItem_swigregister
ThreadDataItem_swigregister(ThreadDataItem)
thread_stacksize = cvar.thread_stacksize

def ThreadDataItem_Get(key):
    return _common.ThreadDataItem_Get(key)
ThreadDataItem_Get = _common.ThreadDataItem_Get

class SimpleCondition(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleCondition, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleCondition, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_SimpleCondition()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_SimpleCondition
    __del__ = lambda self: None

    def lock(self):
        return _common.SimpleCondition_lock(self)

    def unlock(self):
        return _common.SimpleCondition_unlock(self)

    def signal(self):
        return _common.SimpleCondition_signal(self)

    def signal_nonblock(self):
        return _common.SimpleCondition_signal_nonblock(self)

    def broadcast(self):
        return _common.SimpleCondition_broadcast(self)

    def wait_nonblock(self):
        return _common.SimpleCondition_wait_nonblock(self)

    def wait(self, *args):
        return _common.SimpleCondition_wait(self, *args)

    def reset(self):
        return _common.SimpleCondition_reset(self)

    def forceReset(self):
        return _common.SimpleCondition_forceReset(self)
SimpleCondition_swigregister = _common.SimpleCondition_swigregister
SimpleCondition_swigregister(SimpleCondition)

class SimpleCounter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleCounter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleCounter, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_SimpleCounter()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_SimpleCounter
    __del__ = lambda self: None

    def inc(self):
        return _common.SimpleCounter_inc(self)

    def dec(self):
        return _common.SimpleCounter_dec(self)

    def get(self):
        return _common.SimpleCounter_get(self)

    def set(self, v):
        return _common.SimpleCounter_set(self, v)

    def wait(self, *args):
        return _common.SimpleCounter_wait(self, *args)

    def forceReset(self):
        return _common.SimpleCounter_forceReset(self)
SimpleCounter_swigregister = _common.SimpleCounter_swigregister
SimpleCounter_swigregister(SimpleCounter)

class TimedMutex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimedMutex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimedMutex, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_TimedMutex()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_TimedMutex
    __del__ = lambda self: None

    def lock(self, t=-1):
        return _common.TimedMutex_lock(self, t)

    def trylock(self):
        return _common.TimedMutex_trylock(self)

    def unlock(self):
        return _common.TimedMutex_unlock(self)

    def forceReset(self):
        return _common.TimedMutex_forceReset(self)
TimedMutex_swigregister = _common.TimedMutex_swigregister
TimedMutex_swigregister(TimedMutex)

class SharedMutex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedMutex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedMutex, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_SharedMutex()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_SharedMutex
    __del__ = lambda self: None

    def lockShared(self):
        return _common.SharedMutex_lockShared(self)

    def unlockShared(self):
        return _common.SharedMutex_unlockShared(self)

    def isLockShared(self):
        return _common.SharedMutex_isLockShared(self)

    def lockExclusive(self):
        return _common.SharedMutex_lockExclusive(self)

    def unlockExclusive(self):
        return _common.SharedMutex_unlockExclusive(self)

    def isLockExclusive(self):
        return _common.SharedMutex_isLockExclusive(self)

    def forceReset(self):
        return _common.SharedMutex_forceReset(self)
SharedMutex_swigregister = _common.SharedMutex_swigregister
SharedMutex_swigregister(SharedMutex)

class ThreadedPointerBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadedPointerBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadedPointerBase, name)
    __repr__ = _swig_repr

    def __init__(self, p):
        this = _common.new_ThreadedPointerBase(p)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def add(self):
        return _common.ThreadedPointerBase_add(self)

    def rem(self):
        return _common.ThreadedPointerBase_rem(self)

    def ptr(self):
        return _common.ThreadedPointerBase_ptr(self)

    def rel(self):
        return _common.ThreadedPointerBase_rel(self)

    def cnt(self):
        return _common.ThreadedPointerBase_cnt(self)

    def lock(self):
        return _common.ThreadedPointerBase_lock(self)

    def unlock(self):
        return _common.ThreadedPointerBase_unlock(self)

    def wait(self, *args):
        return _common.ThreadedPointerBase_wait(self, *args)
ThreadedPointerBase_swigregister = _common.ThreadedPointerBase_swigregister
ThreadedPointerBase_swigregister(ThreadedPointerBase)

class ThreadRegistry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadRegistry, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_ThreadRegistry()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _common.delete_ThreadRegistry
    __del__ = lambda self: None

    def RegisterThread(self):
        return _common.ThreadRegistry_RegisterThread(self)

    def UnregisterThread(self):
        return _common.ThreadRegistry_UnregisterThread(self)

    def WaitOrCancel(self, timeout):
        return _common.ThreadRegistry_WaitOrCancel(self, timeout)

    def WaitForExit(self, timeout=-1):
        return _common.ThreadRegistry_WaitForExit(self, timeout)

    def RequestCancel(self):
        return _common.ThreadRegistry_RequestCancel(self)

    def forceReset(self):
        return _common.ThreadRegistry_forceReset(self)
ThreadRegistry_swigregister = _common.ThreadRegistry_swigregister
ThreadRegistry_swigregister(ThreadRegistry)


def GlibThreadInitialize():
    return _common.GlibThreadInitialize()
GlibThreadInitialize = _common.GlibThreadInitialize
class ThreadInitializer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadInitializer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadInitializer, name)
    __repr__ = _swig_repr

    def __init__(self):
        this = _common.new_ThreadInitializer()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def forceReset(self):
        return _common.ThreadInitializer_forceReset(self)

    def waitExit(self):
        return _common.ThreadInitializer_waitExit(self)
    __swig_destroy__ = _common.delete_ThreadInitializer
    __del__ = lambda self: None
ThreadInitializer_swigregister = _common.ThreadInitializer_swigregister
ThreadInitializer_swigregister(ThreadInitializer)

class SimpleConditionList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleConditionList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleConditionList, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _common.SimpleConditionList_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _common.SimpleConditionList___nonzero__(self)

    def __bool__(self):
        return _common.SimpleConditionList___bool__(self)

    def __len__(self):
        return _common.SimpleConditionList___len__(self)

    def __getslice__(self, i, j):
        return _common.SimpleConditionList___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _common.SimpleConditionList___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _common.SimpleConditionList___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _common.SimpleConditionList___delitem__(self, *args)

    def __getitem__(self, *args):
        return _common.SimpleConditionList___getitem__(self, *args)

    def __setitem__(self, *args):
        return _common.SimpleConditionList___setitem__(self, *args)

    def pop(self):
        return _common.SimpleConditionList_pop(self)

    def append(self, x):
        return _common.SimpleConditionList_append(self, x)

    def empty(self):
        return _common.SimpleConditionList_empty(self)

    def size(self):
        return _common.SimpleConditionList_size(self)

    def swap(self, v):
        return _common.SimpleConditionList_swap(self, v)

    def begin(self):
        return _common.SimpleConditionList_begin(self)

    def end(self):
        return _common.SimpleConditionList_end(self)

    def rbegin(self):
        return _common.SimpleConditionList_rbegin(self)

    def rend(self):
        return _common.SimpleConditionList_rend(self)

    def clear(self):
        return _common.SimpleConditionList_clear(self)

    def get_allocator(self):
        return _common.SimpleConditionList_get_allocator(self)

    def pop_back(self):
        return _common.SimpleConditionList_pop_back(self)

    def erase(self, *args):
        return _common.SimpleConditionList_erase(self, *args)

    def __init__(self, *args):
        this = _common.new_SimpleConditionList(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def push_back(self, x):
        return _common.SimpleConditionList_push_back(self, x)

    def front(self):
        return _common.SimpleConditionList_front(self)

    def back(self):
        return _common.SimpleConditionList_back(self)

    def assign(self, n, x):
        return _common.SimpleConditionList_assign(self, n, x)

    def resize(self, *args):
        return _common.SimpleConditionList_resize(self, *args)

    def insert(self, *args):
        return _common.SimpleConditionList_insert(self, *args)

    def pop_front(self):
        return _common.SimpleConditionList_pop_front(self)

    def push_front(self, x):
        return _common.SimpleConditionList_push_front(self, x)

    def remove(self, x):
        return _common.SimpleConditionList_remove(self, x)

    def unique(self):
        return _common.SimpleConditionList_unique(self)

    def reverse(self):
        return _common.SimpleConditionList_reverse(self)

    def sort(self):
        return _common.SimpleConditionList_sort(self)

    def merge(self, x):
        return _common.SimpleConditionList_merge(self, x)
    __swig_destroy__ = _common.delete_SimpleConditionList
    __del__ = lambda self: None
SimpleConditionList_swigregister = _common.SimpleConditionList_swigregister
SimpleConditionList_swigregister(SimpleConditionList)

# This file is compatible with both classic and new-style classes.