# This file was automatically generated by SWIG (https://www.swig.org).
# Version 4.1.1
#
# 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 as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _common
else:
    from arc import _common

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    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

# Register SwigPyIterator in _common:
_common.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):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.StringPair_swiginit(self, _common.new_StringPair(*args))
    first = property(_common.StringPair_first_get, _common.StringPair_first_set)
    second = 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

# Register StringPair in _common:
_common.StringPair_swigregister(StringPair)
class StringList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.StringList_swiginit(self, _common.new_StringList(*args))

    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

# Register StringList in _common:
_common.StringList_swigregister(StringList)
class StringSet(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.StringSet_swiginit(self, _common.new_StringSet(*args))

    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

# Register StringSet in _common:
_common.StringSet_swigregister(StringSet)
class StringVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.StringVector_swiginit(self, _common.new_StringVector(*args))

    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

# Register StringVector in _common:
_common.StringVector_swigregister(StringVector)
class StringStringMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.StringStringMap_swiginit(self, _common.new_StringStringMap(*args))

    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

# Register StringStringMap in _common:
_common.StringStringMap_swigregister(StringStringMap)
class NS(StringStringMap):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.NS_swiginit(self, _common.new_NS(*args))
    __swig_destroy__ = _common.delete_NS

# Register NS in _common:
_common.NS_swigregister(NS)
class XMLNode(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.XMLNode_swiginit(self, _common.new_XMLNode(*args))
    __swig_destroy__ = _common.delete_XMLNode

    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, _in):
        return _common.XMLNode_ReadFromStream(self, _in)

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

# Register XMLNode in _common:
_common.XMLNode_swigregister(XMLNode)

def __rshift__(_in, node):
    return _common.__rshift__(_in, node)
class XMLNodeContainer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.XMLNodeContainer_swiginit(self, _common.new_XMLNodeContainer(*args))
    __swig_destroy__ = _common.delete_XMLNodeContainer

    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)

# Register XMLNodeContainer in _common:
_common.XMLNodeContainer_swigregister(XMLNodeContainer)
class XMLNodeList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.XMLNodeList_swiginit(self, _common.new_XMLNodeList(*args))

    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

# Register XMLNodeList in _common:
_common.XMLNodeList_swigregister(XMLNodeList)
class Config(XMLNode):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_Config

    def __init__(self, *args):
        _common.Config_swiginit(self, _common.new_Config(*args))

    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)

    @staticmethod
    def elementtobool(pnode, ename, val):
        return _common.Config_elementtobool(pnode, ename, val)

    @staticmethod
    def elementtoenum(pnode, ename, val, opts):
        return _common.Config_elementtoenum(pnode, ename, val, opts)

# Register Config in _common:
_common.Config_swigregister(Config)
class BaseConfig(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    credential = property(_common.BaseConfig_credential_get, _common.BaseConfig_credential_set)
    key = property(_common.BaseConfig_key_get, _common.BaseConfig_key_set)
    cert = property(_common.BaseConfig_cert_get, _common.BaseConfig_cert_set)
    proxy = property(_common.BaseConfig_proxy_get, _common.BaseConfig_proxy_set)
    cafile = property(_common.BaseConfig_cafile_get, _common.BaseConfig_cafile_set)
    cadir = property(_common.BaseConfig_cadir_get, _common.BaseConfig_cadir_set)
    otoken = property(_common.BaseConfig_otoken_get, _common.BaseConfig_otoken_set)
    overlay = property(_common.BaseConfig_overlay_get, _common.BaseConfig_overlay_set)

    def __init__(self):
        _common.BaseConfig_swiginit(self, _common.new_BaseConfig())
    __swig_destroy__ = _common.delete_BaseConfig

    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 AddOToken(self, token):
        return _common.BaseConfig_AddOToken(self, token)

    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)

# Register BaseConfig in _common:
_common.BaseConfig_swigregister(BaseConfig)
class ArcLocation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def Init(path):
        return _common.ArcLocation_Init(path)

    @staticmethod
    def Get():
        return _common.ArcLocation_Get()

    @staticmethod
    def GetPlugins():
        return _common.ArcLocation_GetPlugins()

    @staticmethod
    def GetDataDir():
        return _common.ArcLocation_GetDataDir()

    @staticmethod
    def GetLibDir():
        return _common.ArcLocation_GetLibDir()

    @staticmethod
    def GetToolsDir():
        return _common.ArcLocation_GetToolsDir()

    def __init__(self):
        _common.ArcLocation_swiginit(self, _common.new_ArcLocation())
    __swig_destroy__ = _common.delete_ArcLocation

# Register ArcLocation in _common:
_common.ArcLocation_swigregister(ArcLocation)
ARC_VERSION = _common.ARC_VERSION
ARC_VERSION_NUM = _common.ARC_VERSION_NUM
ARC_VERSION_MAJOR = _common.ARC_VERSION_MAJOR
ARC_VERSION_MINOR = _common.ARC_VERSION_MINOR
ARC_VERSION_PATCH = _common.ARC_VERSION_PATCH
class ArcVersion(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Major = property(_common.ArcVersion_Major_get)
    Minor = property(_common.ArcVersion_Minor_get)
    Patch = property(_common.ArcVersion_Patch_get)

    def __init__(self, ver):
        _common.ArcVersion_swiginit(self, _common.new_ArcVersion(ver))
    __swig_destroy__ = _common.delete_ArcVersion

# Register ArcVersion in _common:
_common.ArcVersion_swigregister(ArcVersion)
class PrintFBase(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    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)

# Register PrintFBase in _common:
_common.PrintFBase_swigregister(PrintFBase)
cvar = _common.cvar
Version = cvar.Version


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

def FindNTrans(s, p, n):
    return _common.FindNTrans(s, p, n)
class IString(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_IString

    def __init__(self, *args):
        _common.IString_swiginit(self, _common.new_IString(*args))

    def str(self):
        return _common.IString_str(self)

# Register IString in _common:
_common.IString_swigregister(IString)
class CPyOutbuf(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, obj):
        _common.CPyOutbuf_swiginit(self, _common.new_CPyOutbuf(obj))
    __swig_destroy__ = _common.delete_CPyOutbuf

# Register CPyOutbuf in _common:
_common.CPyOutbuf_swigregister(CPyOutbuf)
class CPyOstream(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, obj):
        _common.CPyOstream_swiginit(self, _common.new_CPyOstream(obj))
    __swig_destroy__ = _common.delete_CPyOstream

# Register CPyOstream in _common:
_common.CPyOstream_swigregister(CPyOstream)

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


DEBUG = _common.DEBUG
VERBOSE = _common.VERBOSE
INFO = _common.INFO
WARNING = _common.WARNING
ERROR = _common.ERROR
FATAL = _common.FATAL
LongFormat = _common.LongFormat
MediumFormat = _common.MediumFormat
ShortFormat = _common.ShortFormat
DebugFormat = _common.DebugFormat
EmptyFormat = _common.EmptyFormat
class LoggerFormat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, format):
        _common.LoggerFormat_swiginit(self, _common.new_LoggerFormat(format))
    format = property(_common.LoggerFormat_format_get, _common.LoggerFormat_format_set)
    __swig_destroy__ = _common.delete_LoggerFormat

# Register LoggerFormat in _common:
_common.LoggerFormat_swigregister(LoggerFormat)

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

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

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

def old_level_to_level(old_level):
    return _common.old_level_to_level(old_level)
class LogMessage(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.LogMessage_swiginit(self, _common.new_LogMessage(*args))

    def getLevel(self):
        return _common.LogMessage_getLevel(self)
    __swig_destroy__ = _common.delete_LogMessage

# Register LogMessage in _common:
_common.LogMessage_swigregister(LogMessage)
class LogDestination(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

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

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

    def getFormat(self):
        return _common.LogDestination_getFormat(self)

    @staticmethod
    def setDefaultFormat(newformat):
        return _common.LogDestination_setDefaultFormat(newformat)

    @staticmethod
    def getDefaultFormat():
        return _common.LogDestination_getDefaultFormat()

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

    def getPrefix(self):
        return _common.LogDestination_getPrefix(self)

# Register LogDestination in _common:
_common.LogDestination_swigregister(LogDestination)
class LogStream_ostream(LogDestination):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, destination):
        _common.LogStream_ostream_swiginit(self, _common.new_LogStream_ostream(destination))

    def log(self, message):
        return _common.LogStream_ostream_log(self, message)
    __swig_destroy__ = _common.delete_LogStream_ostream

# Register LogStream_ostream in _common:
_common.LogStream_ostream_swigregister(LogStream_ostream)
class LogFile(LogDestination):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, path):
        _common.LogFile_swiginit(self, _common.new_LogFile(path))
    __swig_destroy__ = _common.delete_LogFile

    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 Reopen(self):
        return _common.LogFile_Reopen(self)

    @staticmethod
    def ReopenAll():
        return _common.LogFile_ReopenAll()

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



    def log(self, message):
        return _common.LogFile_log(self, message)

# Register LogFile in _common:
_common.LogFile_swigregister(LogFile)
class LoggerContext(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

# Register LoggerContext in _common:
_common.LoggerContext_swigregister(LoggerContext)
class Logger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    @staticmethod
    def getRootLogger():
        return _common.Logger_getRootLogger()

    def __init__(self, *args):
        _common.Logger_swiginit(self, _common.new_Logger(*args))
    __swig_destroy__ = _common.delete_Logger

    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, exclude=None):
        return _common.Logger_deleteDestinations(self, exclude)

    def setThreshold(self, threshold):
        return _common.Logger_setThreshold(self, threshold)

    @staticmethod
    def setThresholdForDomain(*args):
        return _common.Logger_setThresholdForDomain(*args)

    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)

# Register Logger in _common:
_common.Logger_swigregister(Logger)
class LogDestinationList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.LogDestinationList_swiginit(self, _common.new_LogDestinationList(*args))

    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

# Register LogDestinationList in _common:
_common.LogDestinationList_swigregister(LogDestinationList)
MDSTime = _common.MDSTime
ASCTime = _common.ASCTime
UserTime = _common.UserTime
ISOTime = _common.ISOTime
UTCTime = _common.UTCTime
RFC1123Time = _common.RFC1123Time
EpochTime = _common.EpochTime
UserExtTime = _common.UserExtTime
ElasticTime = _common.ElasticTime
PeriodNanoseconds = _common.PeriodNanoseconds
PeriodMicroseconds = _common.PeriodMicroseconds
PeriodMiliseconds = _common.PeriodMiliseconds
PeriodSeconds = _common.PeriodSeconds
PeriodMinutes = _common.PeriodMinutes
PeriodHours = _common.PeriodHours
PeriodDays = _common.PeriodDays
PeriodWeeks = _common.PeriodWeeks
class Period(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.Period_swiginit(self, _common.new_Period(*args))

    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

# Register Period in _common:
_common.Period_swigregister(Period)
class Time(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.Time_swiginit(self, _common.new_Time(*args))

    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)

    @staticmethod
    def SetFormat(arg1):
        return _common.Time_SetFormat(arg1)

    @staticmethod
    def GetFormat():
        return _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

# Register Time in _common:
_common.Time_swigregister(Time)

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

def TimeStamp(*args):
    return _common.TimeStamp(*args)
RC_DEFAULT_PORT = _common.RC_DEFAULT_PORT
HTTP_DEFAULT_PORT = _common.HTTP_DEFAULT_PORT
HTTPS_DEFAULT_PORT = _common.HTTPS_DEFAULT_PORT
HTTPG_DEFAULT_PORT = _common.HTTPG_DEFAULT_PORT
LDAP_DEFAULT_PORT = _common.LDAP_DEFAULT_PORT
FTP_DEFAULT_PORT = _common.FTP_DEFAULT_PORT
GSIFTP_DEFAULT_PORT = _common.GSIFTP_DEFAULT_PORT
LFC_DEFAULT_PORT = _common.LFC_DEFAULT_PORT
XROOTD_DEFAULT_PORT = _common.XROOTD_DEFAULT_PORT
S3_DEFAULT_PORT = _common.S3_DEFAULT_PORT
S3_HTTPS_DEFAULT_PORT = _common.S3_HTTPS_DEFAULT_PORT
class URL(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.URL_swiginit(self, _common.new_URL(*args))
    __swig_destroy__ = _common.delete_URL
    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 ChangeURL(self, newurl, encoded=False):
        return _common.URL_ChangeURL(self, newurl, 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)

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

    @staticmethod
    def URIEncode(str):
        return _common.URL_URIEncode(str)

    @staticmethod
    def URIDecode(*args):
        return _common.URL_URIDecode(*args)

# Register URL in _common:
_common.URL_swigregister(URL)
class URLLocation(URL):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.URLLocation_swiginit(self, _common.new_URLLocation(*args))
    __swig_destroy__ = _common.delete_URLLocation

    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)

# Register URLLocation in _common:
_common.URLLocation_swigregister(URLLocation)
class PathIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, path, end=False):
        _common.PathIterator_swiginit(self, _common.new_PathIterator(path, end))
    __swig_destroy__ = _common.delete_PathIterator

    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)

# Register PathIterator in _common:
_common.PathIterator_swigregister(PathIterator)

def ReadURLList(urllist):
    return _common.ReadURLList(urllist)
class URLList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.URLList_swiginit(self, _common.new_URLList(*args))

    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

# Register URLList in _common:
_common.URLList_swigregister(URLList)
class URLVector(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.URLVector_swiginit(self, _common.new_URLVector(*args))

    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

# Register URLVector in _common:
_common.URLVector_swigregister(URLVector)
class URLListMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.URLListMap_swiginit(self, _common.new_URLListMap(*args))

    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

# Register URLListMap in _common:
_common.URLListMap_swigregister(URLListMap)
class URLLocationList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.URLLocationList_swiginit(self, _common.new_URLLocationList(*args))

    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

# Register URLLocationList in _common:
_common.URLLocationList_swigregister(URLLocationList)
class User(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.User_swiginit(self, _common.new_User(*args))

    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

# Register User in _common:
_common.User_swigregister(User)
class UserSwitch(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, uid, gid):
        _common.UserSwitch_swiginit(self, _common.new_UserSwitch(uid, gid))
    __swig_destroy__ = _common.delete_UserSwitch

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



    def resetPostFork(self):
        return _common.UserSwitch_resetPostFork(self)

# Register UserSwitch in _common:
_common.UserSwitch_swigregister(UserSwitch)
class ConfigEndpointList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.ConfigEndpointList_swiginit(self, _common.new_ConfigEndpointList(*args))

    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

# Register ConfigEndpointList in _common:
_common.ConfigEndpointList_swigregister(ConfigEndpointList)
COMPUTING = _common.COMPUTING
INDEX = _common.INDEX
class ConfigEndpoint(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    REGISTRY = _common.ConfigEndpoint_REGISTRY
    COMPUTINGINFO = _common.ConfigEndpoint_COMPUTINGINFO
    ANY = _common.ConfigEndpoint_ANY

    def __init__(self, *args):
        _common.ConfigEndpoint_swiginit(self, _common.new_ConfigEndpoint(*args))
    type = property(_common.ConfigEndpoint_type_get, _common.ConfigEndpoint_type_set)
    URLString = property(_common.ConfigEndpoint_URLString_get, _common.ConfigEndpoint_URLString_set)
    InterfaceName = property(_common.ConfigEndpoint_InterfaceName_get, _common.ConfigEndpoint_InterfaceName_set)
    RequestedSubmissionInterfaceName = 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

# Register ConfigEndpoint in _common:
_common.ConfigEndpoint_swigregister(ConfigEndpoint)

def tostring(st):
    return _common.tostring(st)
class initializeCredentialsType(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.initializeCredentialsType_swiginit(self, _common.new_initializeCredentialsType(*args))

    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

# Register initializeCredentialsType in _common:
_common.initializeCredentialsType_swigregister(initializeCredentialsType)
class UserConfig(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.UserConfig_swiginit(self, _common.new_UserConfig(*args))
    __swig_destroy__ = _common.delete_UserConfig

    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 DefaultVOMSes(self):
        return _common.UserConfig_DefaultVOMSes(self)

    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 OToken(self, *args):
        return _common.UserConfig_OToken(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 IsSameIdentity(self, other):
        return _common.UserConfig_IsSameIdentity(self, other)

    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)

    @staticmethod
    def ARCUSERDIRECTORY():
        return _common.UserConfig_ARCUSERDIRECTORY()

    @staticmethod
    def SYSCONFIG():
        return _common.UserConfig_SYSCONFIG()

    @staticmethod
    def SYSCONFIGARCLOC():
        return _common.UserConfig_SYSCONFIGARCLOC()

    @staticmethod
    def DEFAULTCONFIG():
        return _common.UserConfig_DEFAULTCONFIG()

    @staticmethod
    def EXAMPLECONFIG():
        return _common.UserConfig_EXAMPLECONFIG()

    @staticmethod
    def JOBLISTFILE():
        return _common.UserConfig_JOBLISTFILE()
    DEFAULT_TIMEOUT = _common.UserConfig_DEFAULT_TIMEOUT

    @staticmethod
    def DEFAULT_BROKER():
        return _common.UserConfig_DEFAULT_BROKER()

# Register UserConfig in _common:
_common.UserConfig_swigregister(UserConfig)
class CertEnvLocker(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, cfg):
        _common.CertEnvLocker_swiginit(self, _common.new_CertEnvLocker(cfg))
    __swig_destroy__ = _common.delete_CertEnvLocker

# Register CertEnvLocker in _common:
_common.CertEnvLocker_swigregister(CertEnvLocker)
class ConfigEndpointMap(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.ConfigEndpointMap_swiginit(self, _common.new_ConfigEndpointMap(*args))

    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

# Register ConfigEndpointMap in _common:
_common.ConfigEndpointMap_swigregister(ConfigEndpointMap)

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

def UUID():
    return _common.UUID()
class CheckSum(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    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__



# Register CheckSum in _common:
_common.CheckSum_swigregister(CheckSum)
class CRC32Sum(CheckSum):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.CRC32Sum_swiginit(self, _common.new_CRC32Sum())
    __swig_destroy__ = _common.delete_CRC32Sum

    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)

# Register CRC32Sum in _common:
_common.CRC32Sum_swigregister(CRC32Sum)
class MD5Sum(CheckSum):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.MD5Sum_swiginit(self, _common.new_MD5Sum())

    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

# Register MD5Sum in _common:
_common.MD5Sum_swigregister(MD5Sum)
class Adler32Sum(CheckSum):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.Adler32Sum_swiginit(self, _common.new_Adler32Sum())

    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

# Register Adler32Sum in _common:
_common.Adler32Sum_swigregister(Adler32Sum)
class CheckSumAny(CheckSum):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.CheckSumAny_swiginit(self, _common.new_CheckSumAny(*args))
    __swig_destroy__ = _common.delete_CheckSumAny

    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)

    @staticmethod
    def FileChecksum(*args):
        return _common.CheckSumAny_FileChecksum(*args)

# Register CheckSumAny in _common:
_common.CheckSumAny_swigregister(CheckSumAny)
class JobPerfLog(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.JobPerfLog_swiginit(self, _common.new_JobPerfLog())
    __swig_destroy__ = _common.delete_JobPerfLog

    def SetOutput(self, filename):
        return _common.JobPerfLog_SetOutput(self, filename)

    def SetEnabled(self, enabled):
        return _common.JobPerfLog_SetEnabled(self, enabled)

    def GetOutput(self):
        return _common.JobPerfLog_GetOutput(self)

    def GetEnabled(self):
        return _common.JobPerfLog_GetEnabled(self)

    def Log(self, name, id, start, end):
        return _common.JobPerfLog_Log(self, name, id, start, end)

# Register JobPerfLog in _common:
_common.JobPerfLog_swigregister(JobPerfLog)
class JobPerfRecord(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.JobPerfRecord_swiginit(self, _common.new_JobPerfRecord(*args))

    def Start(self, id):
        return _common.JobPerfRecord_Start(self, id)

    def End(self, name):
        return _common.JobPerfRecord_End(self, name)

    def Started(self):
        return _common.JobPerfRecord_Started(self)
    __swig_destroy__ = _common.delete_JobPerfRecord

# Register JobPerfRecord in _common:
_common.JobPerfRecord_swigregister(JobPerfRecord)

def CreateThreadFunction(func, arg, count=None):
    return _common.CreateThreadFunction(func, arg, count)
class ThreadDataItem(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _common.ThreadDataItem_swiginit(self, _common.new_ThreadDataItem(*args))

    def Attach(self, *args):
        return _common.ThreadDataItem_Attach(self, *args)

    @staticmethod
    def Get(key):
        return _common.ThreadDataItem_Get(key)

    def Dup(self):
        return _common.ThreadDataItem_Dup(self)

# Register ThreadDataItem in _common:
_common.ThreadDataItem_swigregister(ThreadDataItem)
thread_stacksize = cvar.thread_stacksize

class Thread(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def start(self, count=None):
        return _common.Thread_start(self, count)
    __swig_destroy__ = _common.delete_Thread

# Register Thread in _common:
_common.Thread_swigregister(Thread)
class SimpleCondition(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.SimpleCondition_swiginit(self, _common.new_SimpleCondition())
    __swig_destroy__ = _common.delete_SimpleCondition

    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)

# Register SimpleCondition in _common:
_common.SimpleCondition_swigregister(SimpleCondition)
class SimpleCounter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.SimpleCounter_swiginit(self, _common.new_SimpleCounter())
    __swig_destroy__ = _common.delete_SimpleCounter

    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)

# Register SimpleCounter in _common:
_common.SimpleCounter_swigregister(SimpleCounter)
class TimedMutex(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.TimedMutex_swiginit(self, _common.new_TimedMutex())
    __swig_destroy__ = _common.delete_TimedMutex

    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)

# Register TimedMutex in _common:
_common.TimedMutex_swigregister(TimedMutex)
class SharedMutex(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.SharedMutex_swiginit(self, _common.new_SharedMutex())
    __swig_destroy__ = _common.delete_SharedMutex

    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)

# Register SharedMutex in _common:
_common.SharedMutex_swigregister(SharedMutex)
class SharedMutexSharedLock(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mutex):
        _common.SharedMutexSharedLock_swiginit(self, _common.new_SharedMutexSharedLock(mutex))
    __swig_destroy__ = _common.delete_SharedMutexSharedLock

# Register SharedMutexSharedLock in _common:
_common.SharedMutexSharedLock_swigregister(SharedMutexSharedLock)
class SharedMutexExclusiveLock(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, mutex):
        _common.SharedMutexExclusiveLock_swiginit(self, _common.new_SharedMutexExclusiveLock(mutex))
    __swig_destroy__ = _common.delete_SharedMutexExclusiveLock

# Register SharedMutexExclusiveLock in _common:
_common.SharedMutexExclusiveLock_swigregister(SharedMutexExclusiveLock)
class ThreadedPointerBase(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, p):
        _common.ThreadedPointerBase_swiginit(self, _common.new_ThreadedPointerBase(p))

    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)

# Register ThreadedPointerBase in _common:
_common.ThreadedPointerBase_swigregister(ThreadedPointerBase)
class ThreadRegistry(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.ThreadRegistry_swiginit(self, _common.new_ThreadRegistry())
    __swig_destroy__ = _common.delete_ThreadRegistry

    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)

# Register ThreadRegistry in _common:
_common.ThreadRegistry_swigregister(ThreadRegistry)

def GlibThreadInitialize():
    return _common.GlibThreadInitialize()
class ThreadInitializer(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _common.ThreadInitializer_swiginit(self, _common.new_ThreadInitializer())

    def forceReset(self):
        return _common.ThreadInitializer_forceReset(self)

    def waitExit(self):
        return _common.ThreadInitializer_waitExit(self)
    __swig_destroy__ = _common.delete_ThreadInitializer

# Register ThreadInitializer in _common:
_common.ThreadInitializer_swigregister(ThreadInitializer)
class SimpleConditionList(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __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):
        _common.SimpleConditionList_swiginit(self, _common.new_SimpleConditionList(*args))

    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

# Register SimpleConditionList in _common:
_common.SimpleConditionList_swigregister(SimpleConditionList)