# This file was automatically generated by SWIG (http://www.swig.org).
# Version 1.3.40
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
# This file is compatible with both classic and new-style classes.

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

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

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

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

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


class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _common.SwigPyIterator_value(self)
    def incr(self, n = 1): return _common.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _common.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _common.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _common.SwigPyIterator_equal(self, *args)
    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, *args): return _common.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _common.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _common.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _common.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _common.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _common.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _common.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _common.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

import warnings

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

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

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

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



class StringPair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringPair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringPair, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_StringPair(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["first"] = _common.StringPair_first_set
    __swig_getmethods__["first"] = _common.StringPair_first_get
    if _newclass:first = _swig_property(_common.StringPair_first_get, _common.StringPair_first_set)
    __swig_setmethods__["second"] = _common.StringPair_second_set
    __swig_getmethods__["second"] = _common.StringPair_second_get
    if _newclass:second = _swig_property(_common.StringPair_second_get, _common.StringPair_second_set)
    def __len__(self): return 2
    def __repr__(self): return str((self.first, self.second))
    def __getitem__(self, index): 
      if not (index % 2): 
        return self.first
      else:
        return self.second
    def __setitem__(self, index, val):
      if not (index % 2): 
        self.first = val
      else:
        self.second = val
    __swig_destroy__ = _common.delete_StringPair
    __del__ = lambda self : None;
StringPair_swigregister = _common.StringPair_swigregister
StringPair_swigregister(StringPair)

class StringList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringList, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.StringList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.StringList___nonzero__(self)
    def __bool__(self): return _common.StringList___bool__(self)
    def __len__(self): return _common.StringList___len__(self)
    def pop(self): return _common.StringList_pop(self)
    def __getslice__(self, *args): return _common.StringList___getslice__(self, *args)
    def __setslice__(self, *args): return _common.StringList___setslice__(self, *args)
    def __delslice__(self, *args): return _common.StringList___delslice__(self, *args)
    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 append(self, *args): return _common.StringList_append(self, *args)
    def empty(self): return _common.StringList_empty(self)
    def size(self): return _common.StringList_size(self)
    def clear(self): return _common.StringList_clear(self)
    def swap(self, *args): return _common.StringList_swap(self, *args)
    def get_allocator(self): return _common.StringList_get_allocator(self)
    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 pop_back(self): return _common.StringList_pop_back(self)
    def erase(self, *args): return _common.StringList_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_StringList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.StringList_push_back(self, *args)
    def front(self): return _common.StringList_front(self)
    def back(self): return _common.StringList_back(self)
    def assign(self, *args): return _common.StringList_assign(self, *args)
    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, *args): return _common.StringList_push_front(self, *args)
    def reverse(self): return _common.StringList_reverse(self)
    __swig_destroy__ = _common.delete_StringList
    __del__ = lambda self : None;
StringList_swigregister = _common.StringList_swigregister
StringList_swigregister(StringList)

class StringSet(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringSet, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringSet, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.StringSet_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.StringSet___nonzero__(self)
    def __bool__(self): return _common.StringSet___bool__(self)
    def __len__(self): return _common.StringSet___len__(self)
    def append(self, *args): return _common.StringSet_append(self, *args)
    def __contains__(self, *args): return _common.StringSet___contains__(self, *args)
    def __getitem__(self, *args): return _common.StringSet___getitem__(self, *args)
    def __init__(self, *args): 
        this = _common.new_StringSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _common.StringSet_empty(self)
    def size(self): return _common.StringSet_size(self)
    def clear(self): return _common.StringSet_clear(self)
    def swap(self, *args): return _common.StringSet_swap(self, *args)
    def count(self, *args): return _common.StringSet_count(self, *args)
    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, *args): return _common.StringSet_find(self, *args)
    def lower_bound(self, *args): return _common.StringSet_lower_bound(self, *args)
    def upper_bound(self, *args): return _common.StringSet_upper_bound(self, *args)
    def equal_range(self, *args): return _common.StringSet_equal_range(self, *args)
    def insert(self, *args): return _common.StringSet_insert(self, *args)
    __swig_destroy__ = _common.delete_StringSet
    __del__ = lambda self : None;
StringSet_swigregister = _common.StringSet_swigregister
StringSet_swigregister(StringSet)

class StringVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.StringVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.StringVector___nonzero__(self)
    def __bool__(self): return _common.StringVector___bool__(self)
    def __len__(self): return _common.StringVector___len__(self)
    def pop(self): return _common.StringVector_pop(self)
    def __getslice__(self, *args): return _common.StringVector___getslice__(self, *args)
    def __setslice__(self, *args): return _common.StringVector___setslice__(self, *args)
    def __delslice__(self, *args): return _common.StringVector___delslice__(self, *args)
    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 append(self, *args): return _common.StringVector_append(self, *args)
    def empty(self): return _common.StringVector_empty(self)
    def size(self): return _common.StringVector_size(self)
    def clear(self): return _common.StringVector_clear(self)
    def swap(self, *args): return _common.StringVector_swap(self, *args)
    def get_allocator(self): return _common.StringVector_get_allocator(self)
    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 pop_back(self): return _common.StringVector_pop_back(self)
    def erase(self, *args): return _common.StringVector_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_StringVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.StringVector_push_back(self, *args)
    def front(self): return _common.StringVector_front(self)
    def back(self): return _common.StringVector_back(self)
    def assign(self, *args): return _common.StringVector_assign(self, *args)
    def resize(self, *args): return _common.StringVector_resize(self, *args)
    def insert(self, *args): return _common.StringVector_insert(self, *args)
    def reserve(self, *args): return _common.StringVector_reserve(self, *args)
    def capacity(self): return _common.StringVector_capacity(self)
    __swig_destroy__ = _common.delete_StringVector
    __del__ = lambda self : None;
StringVector_swigregister = _common.StringVector_swigregister
StringVector_swigregister(StringVector)

class StringStringMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringStringMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringStringMap, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.StringStringMap_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.StringStringMap___nonzero__(self)
    def __bool__(self): return _common.StringStringMap___bool__(self)
    def __len__(self): return _common.StringStringMap___len__(self)
    def __getitem__(self, *args): return _common.StringStringMap___getitem__(self, *args)
    def __delitem__(self, *args): return _common.StringStringMap___delitem__(self, *args)
    def has_key(self, *args): return _common.StringStringMap_has_key(self, *args)
    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, *args): return _common.StringStringMap___contains__(self, *args)
    def key_iterator(self): return _common.StringStringMap_key_iterator(self)
    def value_iterator(self): return _common.StringStringMap_value_iterator(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 __setitem__(self, *args): return _common.StringStringMap___setitem__(self, *args)
    def __init__(self, *args): 
        this = _common.new_StringStringMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _common.StringStringMap_empty(self)
    def size(self): return _common.StringStringMap_size(self)
    def clear(self): return _common.StringStringMap_clear(self)
    def swap(self, *args): return _common.StringStringMap_swap(self, *args)
    def get_allocator(self): return _common.StringStringMap_get_allocator(self)
    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 count(self, *args): return _common.StringStringMap_count(self, *args)
    def erase(self, *args): return _common.StringStringMap_erase(self, *args)
    def find(self, *args): return _common.StringStringMap_find(self, *args)
    def lower_bound(self, *args): return _common.StringStringMap_lower_bound(self, *args)
    def upper_bound(self, *args): return _common.StringStringMap_upper_bound(self, *args)
    __swig_destroy__ = _common.delete_StringStringMap
    __del__ = lambda self : None;
StringStringMap_swigregister = _common.StringStringMap_swigregister
StringStringMap_swigregister(StringStringMap)

class NS(StringStringMap):
    __swig_setmethods__ = {}
    for _s in [StringStringMap]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, NS, name, value)
    __swig_getmethods__ = {}
    for _s in [StringStringMap]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, NS, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_NS(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_NS
    __del__ = lambda self : None;
NS_swigregister = _common.NS_swigregister
NS_swigregister(NS)

class XMLNode(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNode, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNode, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_XMLNode(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_XMLNode
    __del__ = lambda self : None;
    def New(self, *args): return _common.XMLNode_New(self, *args)
    def Exchange(self, *args): return _common.XMLNode_Exchange(self, *args)
    def Move(self, *args): return _common.XMLNode_Move(self, *args)
    def Swap(self, *args): return _common.XMLNode_Swap(self, *args)
    def __nonzero__(self):
        return _common.XMLNode___nonzero__(self)
    __bool__ = __nonzero__


    def Same(self, *args): return _common.XMLNode_Same(self, *args)
    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, *args): return _common.XMLNode_Get(self, *args)
    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, *args): return _common.XMLNode_Set(self, *args)
    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, *args): return _common.XMLNode_NamespacePrefix(self, *args)
    def NewChild(self, *args): return _common.XMLNode_NewChild(self, *args)
    def Replace(self, *args): return _common.XMLNode_Replace(self, *args)
    def Destroy(self): return _common.XMLNode_Destroy(self)
    def Path(self, *args): return _common.XMLNode_Path(self, *args)
    def XPathLookup(self, *args): return _common.XMLNode_XPathLookup(self, *args)
    def GetRoot(self): return _common.XMLNode_GetRoot(self)
    def Parent(self): return _common.XMLNode_Parent(self)
    def SaveToFile(self, *args): return _common.XMLNode_SaveToFile(self, *args)
    def SaveToStream(self, *args): return _common.XMLNode_SaveToStream(self, *args)
    def ReadFromFile(self, *args): return _common.XMLNode_ReadFromFile(self, *args)
    def ReadFromStream(self, *args): return _common.XMLNode_ReadFromStream(self, *args)
    def Validate(self, *args): return _common.XMLNode_Validate(self, *args)
XMLNode_swigregister = _common.XMLNode_swigregister
XMLNode_swigregister(XMLNode)


def __rshift__(*args):
  return _common.__rshift__(*args)
__rshift__ = _common.__rshift__
class XMLNodeContainer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNodeContainer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNodeContainer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_XMLNodeContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_XMLNodeContainer
    __del__ = lambda self : None;
    def Add(self, *args): return _common.XMLNodeContainer_Add(self, *args)
    def AddNew(self, *args): return _common.XMLNodeContainer_AddNew(self, *args)
    def Size(self): return _common.XMLNodeContainer_Size(self)
    def Nodes(self): return _common.XMLNodeContainer_Nodes(self)
XMLNodeContainer_swigregister = _common.XMLNodeContainer_swigregister
XMLNodeContainer_swigregister(XMLNodeContainer)

class XMLNodeList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, XMLNodeList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, XMLNodeList, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.XMLNodeList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.XMLNodeList___nonzero__(self)
    def __bool__(self): return _common.XMLNodeList___bool__(self)
    def __len__(self): return _common.XMLNodeList___len__(self)
    def pop(self): return _common.XMLNodeList_pop(self)
    def __getslice__(self, *args): return _common.XMLNodeList___getslice__(self, *args)
    def __setslice__(self, *args): return _common.XMLNodeList___setslice__(self, *args)
    def __delslice__(self, *args): return _common.XMLNodeList___delslice__(self, *args)
    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 append(self, *args): return _common.XMLNodeList_append(self, *args)
    def empty(self): return _common.XMLNodeList_empty(self)
    def size(self): return _common.XMLNodeList_size(self)
    def clear(self): return _common.XMLNodeList_clear(self)
    def swap(self, *args): return _common.XMLNodeList_swap(self, *args)
    def get_allocator(self): return _common.XMLNodeList_get_allocator(self)
    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 pop_back(self): return _common.XMLNodeList_pop_back(self)
    def erase(self, *args): return _common.XMLNodeList_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_XMLNodeList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.XMLNodeList_push_back(self, *args)
    def front(self): return _common.XMLNodeList_front(self)
    def back(self): return _common.XMLNodeList_back(self)
    def assign(self, *args): return _common.XMLNodeList_assign(self, *args)
    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, *args): return _common.XMLNodeList_push_front(self, *args)
    def reverse(self): return _common.XMLNodeList_reverse(self)
    __swig_destroy__ = _common.delete_XMLNodeList
    __del__ = lambda self : None;
XMLNodeList_swigregister = _common.XMLNodeList_swigregister
XMLNodeList_swigregister(XMLNodeList)

class Config(XMLNode):
    __swig_setmethods__ = {}
    for _s in [XMLNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Config, name, value)
    __swig_getmethods__ = {}
    for _s in [XMLNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Config, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_Config
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _common.new_Config(*args)
        try: self.this.append(this)
        except: self.this = this
    def _print(self): return _common.Config__print(self)
    def parse(self, *args): return _common.Config_parse(self, *args)
    def getFileName(self): return _common.Config_getFileName(self)
    def setFileName(self, *args): return _common.Config_setFileName(self, *args)
    def save(self, *args): return _common.Config_save(self, *args)
    __swig_getmethods__["elementtobool"] = lambda x: _common.Config_elementtobool
    if _newclass:elementtobool = staticmethod(_common.Config_elementtobool)
    __swig_getmethods__["elementtoenum"] = lambda x: _common.Config_elementtoenum
    if _newclass:elementtoenum = staticmethod(_common.Config_elementtoenum)
Config_swigregister = _common.Config_swigregister
Config_swigregister(Config)

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

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

class BaseConfig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, BaseConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, BaseConfig, name)
    __repr__ = _swig_repr
    __swig_setmethods__["credential"] = _common.BaseConfig_credential_set
    __swig_getmethods__["credential"] = _common.BaseConfig_credential_get
    if _newclass:credential = _swig_property(_common.BaseConfig_credential_get, _common.BaseConfig_credential_set)
    __swig_setmethods__["key"] = _common.BaseConfig_key_set
    __swig_getmethods__["key"] = _common.BaseConfig_key_get
    if _newclass:key = _swig_property(_common.BaseConfig_key_get, _common.BaseConfig_key_set)
    __swig_setmethods__["cert"] = _common.BaseConfig_cert_set
    __swig_getmethods__["cert"] = _common.BaseConfig_cert_get
    if _newclass:cert = _swig_property(_common.BaseConfig_cert_get, _common.BaseConfig_cert_set)
    __swig_setmethods__["proxy"] = _common.BaseConfig_proxy_set
    __swig_getmethods__["proxy"] = _common.BaseConfig_proxy_get
    if _newclass:proxy = _swig_property(_common.BaseConfig_proxy_get, _common.BaseConfig_proxy_set)
    __swig_setmethods__["cafile"] = _common.BaseConfig_cafile_set
    __swig_getmethods__["cafile"] = _common.BaseConfig_cafile_get
    if _newclass:cafile = _swig_property(_common.BaseConfig_cafile_get, _common.BaseConfig_cafile_set)
    __swig_setmethods__["cadir"] = _common.BaseConfig_cadir_set
    __swig_getmethods__["cadir"] = _common.BaseConfig_cadir_get
    if _newclass:cadir = _swig_property(_common.BaseConfig_cadir_get, _common.BaseConfig_cadir_set)
    __swig_setmethods__["otoken"] = _common.BaseConfig_otoken_set
    __swig_getmethods__["otoken"] = _common.BaseConfig_otoken_get
    if _newclass:otoken = _swig_property(_common.BaseConfig_otoken_get, _common.BaseConfig_otoken_set)
    __swig_setmethods__["overlay"] = _common.BaseConfig_overlay_set
    __swig_getmethods__["overlay"] = _common.BaseConfig_overlay_get
    if _newclass:overlay = _swig_property(_common.BaseConfig_overlay_get, _common.BaseConfig_overlay_set)
    def __init__(self): 
        this = _common.new_BaseConfig()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_BaseConfig
    __del__ = lambda self : None;
    def AddPluginsPath(self, *args): return _common.BaseConfig_AddPluginsPath(self, *args)
    def AddCredential(self, *args): return _common.BaseConfig_AddCredential(self, *args)
    def AddPrivateKey(self, *args): return _common.BaseConfig_AddPrivateKey(self, *args)
    def AddCertificate(self, *args): return _common.BaseConfig_AddCertificate(self, *args)
    def AddProxy(self, *args): return _common.BaseConfig_AddProxy(self, *args)
    def AddCAFile(self, *args): return _common.BaseConfig_AddCAFile(self, *args)
    def AddCADir(self, *args): return _common.BaseConfig_AddCADir(self, *args)
    def AddOToken(self, *args): return _common.BaseConfig_AddOToken(self, *args)
    def AddOverlay(self, *args): return _common.BaseConfig_AddOverlay(self, *args)
    def GetOverlay(self, *args): return _common.BaseConfig_GetOverlay(self, *args)
    def MakeConfig(self, *args): return _common.BaseConfig_MakeConfig(self, *args)
BaseConfig_swigregister = _common.BaseConfig_swigregister
BaseConfig_swigregister(BaseConfig)

class ArcLocation(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArcLocation, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArcLocation, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Init"] = lambda x: _common.ArcLocation_Init
    if _newclass:Init = staticmethod(_common.ArcLocation_Init)
    __swig_getmethods__["Get"] = lambda x: _common.ArcLocation_Get
    if _newclass:Get = staticmethod(_common.ArcLocation_Get)
    __swig_getmethods__["GetPlugins"] = lambda x: _common.ArcLocation_GetPlugins
    if _newclass:GetPlugins = staticmethod(_common.ArcLocation_GetPlugins)
    __swig_getmethods__["GetDataDir"] = lambda x: _common.ArcLocation_GetDataDir
    if _newclass:GetDataDir = staticmethod(_common.ArcLocation_GetDataDir)
    __swig_getmethods__["GetLibDir"] = lambda x: _common.ArcLocation_GetLibDir
    if _newclass:GetLibDir = staticmethod(_common.ArcLocation_GetLibDir)
    __swig_getmethods__["GetToolsDir"] = lambda x: _common.ArcLocation_GetToolsDir
    if _newclass:GetToolsDir = staticmethod(_common.ArcLocation_GetToolsDir)
    def __init__(self): 
        this = _common.new_ArcLocation()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_ArcLocation
    __del__ = lambda self : None;
ArcLocation_swigregister = _common.ArcLocation_swigregister
ArcLocation_swigregister(ArcLocation)

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

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

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

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

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

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

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):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArcVersion, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ArcVersion, name)
    __repr__ = _swig_repr
    __swig_getmethods__["Major"] = _common.ArcVersion_Major_get
    if _newclass:Major = _swig_property(_common.ArcVersion_Major_get)
    __swig_getmethods__["Minor"] = _common.ArcVersion_Minor_get
    if _newclass:Minor = _swig_property(_common.ArcVersion_Minor_get)
    __swig_getmethods__["Patch"] = _common.ArcVersion_Patch_get
    if _newclass:Patch = _swig_property(_common.ArcVersion_Patch_get)
    def __init__(self, *args): 
        this = _common.new_ArcVersion(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_ArcVersion
    __del__ = lambda self : None;
ArcVersion_swigregister = _common.ArcVersion_swigregister
ArcVersion_swigregister(ArcVersion)

class PrintFBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PrintFBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PrintFBase, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_PrintFBase
    __del__ = lambda self : None;
    def msg(self, *args): return _common.PrintFBase_msg(self, *args)
    def Retain(self): return _common.PrintFBase_Retain(self)
    def Release(self): return _common.PrintFBase_Release(self)
PrintFBase_swigregister = _common.PrintFBase_swigregister
PrintFBase_swigregister(PrintFBase)
cvar = _common.cvar
Version = cvar.Version


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

def FindNTrans(*args):
  return _common.FindNTrans(*args)
FindNTrans = _common.FindNTrans
class IString(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, IString, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, IString, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_IString
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _common.new_IString(*args)
        try: self.this.append(this)
        except: self.this = this
    def str(self): return _common.IString_str(self)
IString_swigregister = _common.IString_swigregister
IString_swigregister(IString)

class CPyOutbuf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyOutbuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPyOutbuf, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_CPyOutbuf(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_CPyOutbuf
    __del__ = lambda self : None;
CPyOutbuf_swigregister = _common.CPyOutbuf_swigregister
CPyOutbuf_swigregister(CPyOutbuf)

class CPyOstream(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CPyOstream, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CPyOstream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_CPyOstream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_CPyOstream
    __del__ = lambda self : None;
CPyOstream_swigregister = _common.CPyOstream_swigregister
CPyOstream_swigregister(CPyOstream)

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


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):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LoggerFormat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LoggerFormat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_LoggerFormat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["format"] = _common.LoggerFormat_format_set
    __swig_getmethods__["format"] = _common.LoggerFormat_format_get
    if _newclass:format = _swig_property(_common.LoggerFormat_format_get, _common.LoggerFormat_format_set)
    __swig_destroy__ = _common.delete_LoggerFormat
    __del__ = lambda self : None;
LoggerFormat_swigregister = _common.LoggerFormat_swigregister
LoggerFormat_swigregister(LoggerFormat)


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

def old_level_to_level(*args):
  return _common.old_level_to_level(*args)
old_level_to_level = _common.old_level_to_level
class LogMessage(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogMessage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogMessage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_LogMessage(*args)
        try: self.this.append(this)
        except: self.this = this
    def getLevel(self): return _common.LogMessage_getLevel(self)
    __swig_destroy__ = _common.delete_LogMessage
    __del__ = lambda self : None;
LogMessage_swigregister = _common.LogMessage_swigregister
LogMessage_swigregister(LogMessage)

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

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

class LogDestination(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogDestination, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogDestination, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def log(self, *args): return _common.LogDestination_log(self, *args)
    __swig_destroy__ = _common.delete_LogDestination
    __del__ = lambda self : None;
    def setFormat(self, *args): return _common.LogDestination_setFormat(self, *args)
    def getFormat(self): return _common.LogDestination_getFormat(self)
    __swig_getmethods__["setDefaultFormat"] = lambda x: _common.LogDestination_setDefaultFormat
    if _newclass:setDefaultFormat = staticmethod(_common.LogDestination_setDefaultFormat)
    __swig_getmethods__["getDefaultFormat"] = lambda x: _common.LogDestination_getDefaultFormat
    if _newclass:getDefaultFormat = staticmethod(_common.LogDestination_getDefaultFormat)
    def setPrefix(self, *args): return _common.LogDestination_setPrefix(self, *args)
    def getPrefix(self): return _common.LogDestination_getPrefix(self)
LogDestination_swigregister = _common.LogDestination_swigregister
LogDestination_swigregister(LogDestination)

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

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

class LogStream_ostream(LogDestination):
    __swig_setmethods__ = {}
    for _s in [LogDestination]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogStream_ostream, name, value)
    __swig_getmethods__ = {}
    for _s in [LogDestination]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LogStream_ostream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_LogStream_ostream(*args)
        try: self.this.append(this)
        except: self.this = this
    def log(self, *args): return _common.LogStream_ostream_log(self, *args)
    __swig_destroy__ = _common.delete_LogStream_ostream
    __del__ = lambda self : None;
LogStream_ostream_swigregister = _common.LogStream_ostream_swigregister
LogStream_ostream_swigregister(LogStream_ostream)

class LogFile(LogDestination):
    __swig_setmethods__ = {}
    for _s in [LogDestination]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogFile, name, value)
    __swig_getmethods__ = {}
    for _s in [LogDestination]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LogFile, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_LogFile(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_LogFile
    __del__ = lambda self : None;
    def setMaxSize(self, *args): return _common.LogFile_setMaxSize(self, *args)
    def setBackups(self, *args): return _common.LogFile_setBackups(self, *args)
    def setReopen(self, *args): return _common.LogFile_setReopen(self, *args)
    def Reopen(self): return _common.LogFile_Reopen(self)
    __swig_getmethods__["ReopenAll"] = lambda x: _common.LogFile_ReopenAll
    if _newclass:ReopenAll = staticmethod(_common.LogFile_ReopenAll)
    def __nonzero__(self):
        return _common.LogFile___nonzero__(self)
    __bool__ = __nonzero__


    def log(self, *args): return _common.LogFile_log(self, *args)
LogFile_swigregister = _common.LogFile_swigregister
LogFile_swigregister(LogFile)

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

class LoggerContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LoggerContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LoggerContext, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
LoggerContext_swigregister = _common.LoggerContext_swigregister
LoggerContext_swigregister(LoggerContext)

class Logger(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Logger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Logger, name)
    __repr__ = _swig_repr
    __swig_getmethods__["getRootLogger"] = lambda x: _common.Logger_getRootLogger
    if _newclass:getRootLogger = staticmethod(_common.Logger_getRootLogger)
    def __init__(self, *args): 
        this = _common.new_Logger(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_Logger
    __del__ = lambda self : None;
    def addDestination(self, *args): return _common.Logger_addDestination(self, *args)
    def addDestinations(self, *args): return _common.Logger_addDestinations(self, *args)
    def setDestinations(self, *args): return _common.Logger_setDestinations(self, *args)
    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, *args): return _common.Logger_setThreshold(self, *args)
    __swig_getmethods__["setThresholdForDomain"] = lambda x: _common.Logger_setThresholdForDomain
    if _newclass:setThresholdForDomain = staticmethod(_common.Logger_setThresholdForDomain)
    def getThreshold(self): return _common.Logger_getThreshold(self)
    def setThreadContext(self): return _common.Logger_setThreadContext(self)
    def msg(self, *args): return _common.Logger_msg(self, *args)
Logger_swigregister = _common.Logger_swigregister
Logger_swigregister(Logger)

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

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

class LogDestinationList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LogDestinationList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LogDestinationList, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.LogDestinationList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.LogDestinationList___nonzero__(self)
    def __bool__(self): return _common.LogDestinationList___bool__(self)
    def __len__(self): return _common.LogDestinationList___len__(self)
    def pop(self): return _common.LogDestinationList_pop(self)
    def __getslice__(self, *args): return _common.LogDestinationList___getslice__(self, *args)
    def __setslice__(self, *args): return _common.LogDestinationList___setslice__(self, *args)
    def __delslice__(self, *args): return _common.LogDestinationList___delslice__(self, *args)
    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 append(self, *args): return _common.LogDestinationList_append(self, *args)
    def empty(self): return _common.LogDestinationList_empty(self)
    def size(self): return _common.LogDestinationList_size(self)
    def clear(self): return _common.LogDestinationList_clear(self)
    def swap(self, *args): return _common.LogDestinationList_swap(self, *args)
    def get_allocator(self): return _common.LogDestinationList_get_allocator(self)
    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 pop_back(self): return _common.LogDestinationList_pop_back(self)
    def erase(self, *args): return _common.LogDestinationList_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_LogDestinationList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.LogDestinationList_push_back(self, *args)
    def front(self): return _common.LogDestinationList_front(self)
    def back(self): return _common.LogDestinationList_back(self)
    def assign(self, *args): return _common.LogDestinationList_assign(self, *args)
    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, *args): return _common.LogDestinationList_push_front(self, *args)
    def remove(self, *args): return _common.LogDestinationList_remove(self, *args)
    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, *args): return _common.LogDestinationList_merge(self, *args)
    __swig_destroy__ = _common.delete_LogDestinationList
    __del__ = lambda self : None;
LogDestinationList_swigregister = _common.LogDestinationList_swigregister
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):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Period, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Period, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_Period(*args)
        try: self.this.append(this)
        except: self.this = this
    def SetPeriod(self, *args): return _common.Period_SetPeriod(self, *args)
    def GetPeriod(self): return _common.Period_GetPeriod(self)
    def GetPeriodNanoseconds(self): return _common.Period_GetPeriodNanoseconds(self)
    def istr(self): return _common.Period_istr(self)
    def __str__(self): return _common.Period___str__(self)
    def __lt__(self, *args): return _common.Period___lt__(self, *args)
    def __gt__(self, *args): return _common.Period___gt__(self, *args)
    def __le__(self, *args): return _common.Period___le__(self, *args)
    def __ge__(self, *args): return _common.Period___ge__(self, *args)
    def __eq__(self, *args): return _common.Period___eq__(self, *args)
    def __ne__(self, *args): return _common.Period___ne__(self, *args)
    def __iadd__(self, *args): return _common.Period___iadd__(self, *args)
    __swig_destroy__ = _common.delete_Period
    __del__ = lambda self : None;
Period_swigregister = _common.Period_swigregister
Period_swigregister(Period)

class Time(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Time, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Time, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_Time(*args)
        try: self.this.append(this)
        except: self.this = this
    def SetTime(self, *args): return _common.Time_SetTime(self, *args)
    def GetTime(self): return _common.Time_GetTime(self)
    def GetTimeNanoseconds(self): return _common.Time_GetTimeNanoseconds(self)
    def __str__(self): return _common.Time___str__(self)
    def str(self, *args): return _common.Time_str(self, *args)
    __swig_getmethods__["SetFormat"] = lambda x: _common.Time_SetFormat
    if _newclass:SetFormat = staticmethod(_common.Time_SetFormat)
    __swig_getmethods__["GetFormat"] = lambda x: _common.Time_GetFormat
    if _newclass:GetFormat = staticmethod(_common.Time_GetFormat)
    def __lt__(self, *args): return _common.Time___lt__(self, *args)
    def __gt__(self, *args): return _common.Time___gt__(self, *args)
    def __le__(self, *args): return _common.Time___le__(self, *args)
    def __ge__(self, *args): return _common.Time___ge__(self, *args)
    def __eq__(self, *args): return _common.Time___eq__(self, *args)
    def __ne__(self, *args): return _common.Time___ne__(self, *args)
    def __add__(self, *args): return _common.Time___add__(self, *args)
    def __sub__(self, *args): return _common.Time___sub__(self, *args)
    YEAR = _common.Time_YEAR
    MONTH = _common.Time_MONTH
    WEEK = _common.Time_WEEK
    DAY = _common.Time_DAY
    HOUR = _common.Time_HOUR
    __swig_destroy__ = _common.delete_Time
    __del__ = lambda self : None;
Time_swigregister = _common.Time_swigregister
Time_swigregister(Time)

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

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

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):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URL, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URL, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_URL(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_URL
    __del__ = lambda self : None;
    base = _common.URL_base
    onelevel = _common.URL_onelevel
    subtree = _common.URL_subtree
    def Protocol(self): return _common.URL_Protocol(self)
    def ChangeProtocol(self, *args): return _common.URL_ChangeProtocol(self, *args)
    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, *args): return _common.URL_ChangeHost(self, *args)
    def Port(self): return _common.URL_Port(self)
    def ChangePort(self, *args): return _common.URL_ChangePort(self, *args)
    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, *args): return _common.URL_ChangePath(self, *args)
    def ChangeFullPath(self, *args): return _common.URL_ChangeFullPath(self, *args)
    def ChangeURL(self, *args): return _common.URL_ChangeURL(self, *args)
    def HTTPOptions(self): return _common.URL_HTTPOptions(self)
    def HTTPOption(self, *args): return _common.URL_HTTPOption(self, *args)
    def AddHTTPOption(self, *args): return _common.URL_AddHTTPOption(self, *args)
    def RemoveHTTPOption(self, *args): return _common.URL_RemoveHTTPOption(self, *args)
    def LDAPAttributes(self): return _common.URL_LDAPAttributes(self)
    def AddLDAPAttribute(self, *args): return _common.URL_AddLDAPAttribute(self, *args)
    def LDAPScope(self): return _common.URL_LDAPScope(self)
    def ChangeLDAPScope(self, *args): return _common.URL_ChangeLDAPScope(self, *args)
    def LDAPFilter(self): return _common.URL_LDAPFilter(self)
    def ChangeLDAPFilter(self, *args): return _common.URL_ChangeLDAPFilter(self, *args)
    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, *args): return _common.URL_AddMetaDataOption(self, *args)
    def AddLocation(self, *args): return _common.URL_AddLocation(self, *args)
    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, *args): return _common.URL_RemoveOption(self, *args)
    def RemoveMetaDataOption(self, *args): return _common.URL_RemoveMetaDataOption(self, *args)
    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, *args): return _common.URL___lt__(self, *args)
    def __eq__(self, *args): return _common.URL___eq__(self, *args)
    def __nonzero__(self):
        return _common.URL___nonzero__(self)
    __bool__ = __nonzero__


    def StringMatches(self, *args): return _common.URL_StringMatches(self, *args)
    def ParseOptions(self, *args): return _common.URL_ParseOptions(self, *args)
    __swig_getmethods__["OptionString"] = lambda x: _common.URL_OptionString
    if _newclass:OptionString = staticmethod(_common.URL_OptionString)
    __swig_getmethods__["URIEncode"] = lambda x: _common.URL_URIEncode
    if _newclass:URIEncode = staticmethod(_common.URL_URIEncode)
    __swig_getmethods__["URIDecode"] = lambda x: _common.URL_URIDecode
    if _newclass:URIDecode = staticmethod(_common.URL_URIDecode)
URL_swigregister = _common.URL_swigregister
URL_swigregister(URL)

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

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

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

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

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

class URLLocation(URL):
    __swig_setmethods__ = {}
    for _s in [URL]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLLocation, name, value)
    __swig_getmethods__ = {}
    for _s in [URL]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, URLLocation, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_URLLocation(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_URLLocation
    __del__ = lambda self : None;
    def Name(self): return _common.URLLocation_Name(self)
    def str(self, encode = False): return _common.URLLocation_str(self, encode)
    def fullstr(self, encode = False): return _common.URLLocation_fullstr(self, encode)
URLLocation_swigregister = _common.URLLocation_swigregister
URLLocation_swigregister(URLLocation)

class PathIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PathIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PathIterator, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_PathIterator(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_PathIterator
    __del__ = lambda self : None;
    def __nonzero__(self):
        return _common.PathIterator___nonzero__(self)
    __bool__ = __nonzero__


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


def ReadURLList(*args):
  return _common.ReadURLList(*args)
ReadURLList = _common.ReadURLList
class URLList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLList, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.URLList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.URLList___nonzero__(self)
    def __bool__(self): return _common.URLList___bool__(self)
    def __len__(self): return _common.URLList___len__(self)
    def pop(self): return _common.URLList_pop(self)
    def __getslice__(self, *args): return _common.URLList___getslice__(self, *args)
    def __setslice__(self, *args): return _common.URLList___setslice__(self, *args)
    def __delslice__(self, *args): return _common.URLList___delslice__(self, *args)
    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 append(self, *args): return _common.URLList_append(self, *args)
    def empty(self): return _common.URLList_empty(self)
    def size(self): return _common.URLList_size(self)
    def clear(self): return _common.URLList_clear(self)
    def swap(self, *args): return _common.URLList_swap(self, *args)
    def get_allocator(self): return _common.URLList_get_allocator(self)
    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 pop_back(self): return _common.URLList_pop_back(self)
    def erase(self, *args): return _common.URLList_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_URLList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.URLList_push_back(self, *args)
    def front(self): return _common.URLList_front(self)
    def back(self): return _common.URLList_back(self)
    def assign(self, *args): return _common.URLList_assign(self, *args)
    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, *args): return _common.URLList_push_front(self, *args)
    def reverse(self): return _common.URLList_reverse(self)
    __swig_destroy__ = _common.delete_URLList
    __del__ = lambda self : None;
URLList_swigregister = _common.URLList_swigregister
URLList_swigregister(URLList)

class URLVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.URLVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.URLVector___nonzero__(self)
    def __bool__(self): return _common.URLVector___bool__(self)
    def __len__(self): return _common.URLVector___len__(self)
    def pop(self): return _common.URLVector_pop(self)
    def __getslice__(self, *args): return _common.URLVector___getslice__(self, *args)
    def __setslice__(self, *args): return _common.URLVector___setslice__(self, *args)
    def __delslice__(self, *args): return _common.URLVector___delslice__(self, *args)
    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 append(self, *args): return _common.URLVector_append(self, *args)
    def empty(self): return _common.URLVector_empty(self)
    def size(self): return _common.URLVector_size(self)
    def clear(self): return _common.URLVector_clear(self)
    def swap(self, *args): return _common.URLVector_swap(self, *args)
    def get_allocator(self): return _common.URLVector_get_allocator(self)
    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 pop_back(self): return _common.URLVector_pop_back(self)
    def erase(self, *args): return _common.URLVector_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_URLVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.URLVector_push_back(self, *args)
    def front(self): return _common.URLVector_front(self)
    def back(self): return _common.URLVector_back(self)
    def assign(self, *args): return _common.URLVector_assign(self, *args)
    def resize(self, *args): return _common.URLVector_resize(self, *args)
    def insert(self, *args): return _common.URLVector_insert(self, *args)
    def reserve(self, *args): return _common.URLVector_reserve(self, *args)
    def capacity(self): return _common.URLVector_capacity(self)
    __swig_destroy__ = _common.delete_URLVector
    __del__ = lambda self : None;
URLVector_swigregister = _common.URLVector_swigregister
URLVector_swigregister(URLVector)

class URLListMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLListMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLListMap, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.URLListMap_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.URLListMap___nonzero__(self)
    def __bool__(self): return _common.URLListMap___bool__(self)
    def __len__(self): return _common.URLListMap___len__(self)
    def __getitem__(self, *args): return _common.URLListMap___getitem__(self, *args)
    def __delitem__(self, *args): return _common.URLListMap___delitem__(self, *args)
    def has_key(self, *args): return _common.URLListMap_has_key(self, *args)
    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, *args): return _common.URLListMap___contains__(self, *args)
    def key_iterator(self): return _common.URLListMap_key_iterator(self)
    def value_iterator(self): return _common.URLListMap_value_iterator(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 __setitem__(self, *args): return _common.URLListMap___setitem__(self, *args)
    def __init__(self, *args): 
        this = _common.new_URLListMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _common.URLListMap_empty(self)
    def size(self): return _common.URLListMap_size(self)
    def clear(self): return _common.URLListMap_clear(self)
    def swap(self, *args): return _common.URLListMap_swap(self, *args)
    def get_allocator(self): return _common.URLListMap_get_allocator(self)
    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 count(self, *args): return _common.URLListMap_count(self, *args)
    def erase(self, *args): return _common.URLListMap_erase(self, *args)
    def find(self, *args): return _common.URLListMap_find(self, *args)
    def lower_bound(self, *args): return _common.URLListMap_lower_bound(self, *args)
    def upper_bound(self, *args): return _common.URLListMap_upper_bound(self, *args)
    __swig_destroy__ = _common.delete_URLListMap
    __del__ = lambda self : None;
URLListMap_swigregister = _common.URLListMap_swigregister
URLListMap_swigregister(URLListMap)

class URLLocationList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, URLLocationList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, URLLocationList, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.URLLocationList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.URLLocationList___nonzero__(self)
    def __bool__(self): return _common.URLLocationList___bool__(self)
    def __len__(self): return _common.URLLocationList___len__(self)
    def pop(self): return _common.URLLocationList_pop(self)
    def __getslice__(self, *args): return _common.URLLocationList___getslice__(self, *args)
    def __setslice__(self, *args): return _common.URLLocationList___setslice__(self, *args)
    def __delslice__(self, *args): return _common.URLLocationList___delslice__(self, *args)
    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 append(self, *args): return _common.URLLocationList_append(self, *args)
    def empty(self): return _common.URLLocationList_empty(self)
    def size(self): return _common.URLLocationList_size(self)
    def clear(self): return _common.URLLocationList_clear(self)
    def swap(self, *args): return _common.URLLocationList_swap(self, *args)
    def get_allocator(self): return _common.URLLocationList_get_allocator(self)
    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 pop_back(self): return _common.URLLocationList_pop_back(self)
    def erase(self, *args): return _common.URLLocationList_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_URLLocationList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.URLLocationList_push_back(self, *args)
    def front(self): return _common.URLLocationList_front(self)
    def back(self): return _common.URLLocationList_back(self)
    def assign(self, *args): return _common.URLLocationList_assign(self, *args)
    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, *args): return _common.URLLocationList_push_front(self, *args)
    def reverse(self): return _common.URLLocationList_reverse(self)
    __swig_destroy__ = _common.delete_URLLocationList
    __del__ = lambda self : None;
URLLocationList_swigregister = _common.URLLocationList_swigregister
URLLocationList_swigregister(URLLocationList)

class User(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, User, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, User, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_User(*args)
        try: self.this.append(this)
        except: self.this = this
    def __nonzero__(self):
        return _common.User___nonzero__(self)
    __bool__ = __nonzero__


    def Name(self): return _common.User_Name(self)
    def Home(self): return _common.User_Home(self)
    def get_uid(self): return _common.User_get_uid(self)
    def get_gid(self): return _common.User_get_gid(self)
    def __eq__(self, *args): return _common.User___eq__(self, *args)
    def check_file_access(self, *args): return _common.User_check_file_access(self, *args)
    def SwitchUser(self): return _common.User_SwitchUser(self)
    __swig_destroy__ = _common.delete_User
    __del__ = lambda self : None;
User_swigregister = _common.User_swigregister
User_swigregister(User)

class UserSwitch(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UserSwitch, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UserSwitch, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_UserSwitch(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_UserSwitch
    __del__ = lambda self : None;
    def __nonzero__(self):
        return _common.UserSwitch___nonzero__(self)
    __bool__ = __nonzero__


    def resetPostFork(self): return _common.UserSwitch_resetPostFork(self)
UserSwitch_swigregister = _common.UserSwitch_swigregister
UserSwitch_swigregister(UserSwitch)

class ConfigEndpointList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigEndpointList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigEndpointList, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.ConfigEndpointList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.ConfigEndpointList___nonzero__(self)
    def __bool__(self): return _common.ConfigEndpointList___bool__(self)
    def __len__(self): return _common.ConfigEndpointList___len__(self)
    def pop(self): return _common.ConfigEndpointList_pop(self)
    def __getslice__(self, *args): return _common.ConfigEndpointList___getslice__(self, *args)
    def __setslice__(self, *args): return _common.ConfigEndpointList___setslice__(self, *args)
    def __delslice__(self, *args): return _common.ConfigEndpointList___delslice__(self, *args)
    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 append(self, *args): return _common.ConfigEndpointList_append(self, *args)
    def empty(self): return _common.ConfigEndpointList_empty(self)
    def size(self): return _common.ConfigEndpointList_size(self)
    def clear(self): return _common.ConfigEndpointList_clear(self)
    def swap(self, *args): return _common.ConfigEndpointList_swap(self, *args)
    def get_allocator(self): return _common.ConfigEndpointList_get_allocator(self)
    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 pop_back(self): return _common.ConfigEndpointList_pop_back(self)
    def erase(self, *args): return _common.ConfigEndpointList_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_ConfigEndpointList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.ConfigEndpointList_push_back(self, *args)
    def front(self): return _common.ConfigEndpointList_front(self)
    def back(self): return _common.ConfigEndpointList_back(self)
    def assign(self, *args): return _common.ConfigEndpointList_assign(self, *args)
    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, *args): return _common.ConfigEndpointList_push_front(self, *args)
    def reverse(self): return _common.ConfigEndpointList_reverse(self)
    __swig_destroy__ = _common.delete_ConfigEndpointList
    __del__ = lambda self : None;
ConfigEndpointList_swigregister = _common.ConfigEndpointList_swigregister
ConfigEndpointList_swigregister(ConfigEndpointList)

COMPUTING = _common.COMPUTING
INDEX = _common.INDEX
class ConfigEndpoint(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigEndpoint, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigEndpoint, name)
    __repr__ = _swig_repr
    REGISTRY = _common.ConfigEndpoint_REGISTRY
    COMPUTINGINFO = _common.ConfigEndpoint_COMPUTINGINFO
    ANY = _common.ConfigEndpoint_ANY
    def __init__(self, *args): 
        this = _common.new_ConfigEndpoint(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["type"] = _common.ConfigEndpoint_type_set
    __swig_getmethods__["type"] = _common.ConfigEndpoint_type_get
    if _newclass:type = _swig_property(_common.ConfigEndpoint_type_get, _common.ConfigEndpoint_type_set)
    __swig_setmethods__["URLString"] = _common.ConfigEndpoint_URLString_set
    __swig_getmethods__["URLString"] = _common.ConfigEndpoint_URLString_get
    if _newclass:URLString = _swig_property(_common.ConfigEndpoint_URLString_get, _common.ConfigEndpoint_URLString_set)
    __swig_setmethods__["InterfaceName"] = _common.ConfigEndpoint_InterfaceName_set
    __swig_getmethods__["InterfaceName"] = _common.ConfigEndpoint_InterfaceName_get
    if _newclass:InterfaceName = _swig_property(_common.ConfigEndpoint_InterfaceName_get, _common.ConfigEndpoint_InterfaceName_set)
    __swig_setmethods__["RequestedSubmissionInterfaceName"] = _common.ConfigEndpoint_RequestedSubmissionInterfaceName_set
    __swig_getmethods__["RequestedSubmissionInterfaceName"] = _common.ConfigEndpoint_RequestedSubmissionInterfaceName_get
    if _newclass:RequestedSubmissionInterfaceName = _swig_property(_common.ConfigEndpoint_RequestedSubmissionInterfaceName_get, _common.ConfigEndpoint_RequestedSubmissionInterfaceName_set)
    def __nonzero__(self):
        return _common.ConfigEndpoint___nonzero__(self)
    __bool__ = __nonzero__


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


def tostring(*args):
  return _common.tostring(*args)
tostring = _common.tostring
class initializeCredentialsType(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, initializeCredentialsType, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, initializeCredentialsType, name)
    __repr__ = _swig_repr
    SkipCredentials = _common.initializeCredentialsType_SkipCredentials
    NotTryCredentials = _common.initializeCredentialsType_NotTryCredentials
    TryCredentials = _common.initializeCredentialsType_TryCredentials
    RequireCredentials = _common.initializeCredentialsType_RequireCredentials
    SkipCANotTryCredentials = _common.initializeCredentialsType_SkipCANotTryCredentials
    SkipCATryCredentials = _common.initializeCredentialsType_SkipCATryCredentials
    SkipCARequireCredentials = _common.initializeCredentialsType_SkipCARequireCredentials
    def __init__(self, *args): 
        this = _common.new_initializeCredentialsType(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args): return _common.initializeCredentialsType___eq__(self, *args)
    def __ne__(self, *args): return _common.initializeCredentialsType___ne__(self, *args)
    def toValue(self): return _common.initializeCredentialsType_toValue(self)
    __swig_destroy__ = _common.delete_initializeCredentialsType
    __del__ = lambda self : None;
initializeCredentialsType_swigregister = _common.initializeCredentialsType_swigregister
initializeCredentialsType_swigregister(initializeCredentialsType)

class UserConfig(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, UserConfig, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, UserConfig, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_UserConfig(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_UserConfig
    __del__ = lambda self : None;
    def InitializeCredentials(self, *args): return _common.UserConfig_InitializeCredentials(self, *args)
    def CredentialsFound(self): return _common.UserConfig_CredentialsFound(self)
    def LoadConfigurationFile(self, *args): return _common.UserConfig_LoadConfigurationFile(self, *args)
    def SaveToFile(self, *args): return _common.UserConfig_SaveToFile(self, *args)
    def ApplyToConfig(self, *args): return _common.UserConfig_ApplyToConfig(self, *args)
    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, *args): return _common.UserConfig_IsSameIdentity(self, *args)
    def StoreDirectory(self, *args): return _common.UserConfig_StoreDirectory(self, *args)
    def JobDownloadDirectory(self, *args): return _common.UserConfig_JobDownloadDirectory(self, *args)
    def IdPName(self, *args): return _common.UserConfig_IdPName(self, *args)
    def OverlayFile(self, *args): return _common.UserConfig_OverlayFile(self, *args)
    def UtilsDirPath(self, *args): return _common.UserConfig_UtilsDirPath(self, *args)
    def SetUser(self, *args): return _common.UserConfig_SetUser(self, *args)
    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, *args): return _common.UserConfig_AddRejectDiscoveryURLs(self, *args)
    def ClearRejectDiscoveryURLs(self): return _common.UserConfig_ClearRejectDiscoveryURLs(self)
    def RejectManagementURLs(self): return _common.UserConfig_RejectManagementURLs(self)
    def GetService(self, *args): return _common.UserConfig_GetService(self, *args)
    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)
    __swig_getmethods__["ARCUSERDIRECTORY"] = lambda x: _common.UserConfig_ARCUSERDIRECTORY
    if _newclass:ARCUSERDIRECTORY = staticmethod(_common.UserConfig_ARCUSERDIRECTORY)
    __swig_getmethods__["SYSCONFIG"] = lambda x: _common.UserConfig_SYSCONFIG
    if _newclass:SYSCONFIG = staticmethod(_common.UserConfig_SYSCONFIG)
    __swig_getmethods__["SYSCONFIGARCLOC"] = lambda x: _common.UserConfig_SYSCONFIGARCLOC
    if _newclass:SYSCONFIGARCLOC = staticmethod(_common.UserConfig_SYSCONFIGARCLOC)
    __swig_getmethods__["DEFAULTCONFIG"] = lambda x: _common.UserConfig_DEFAULTCONFIG
    if _newclass:DEFAULTCONFIG = staticmethod(_common.UserConfig_DEFAULTCONFIG)
    __swig_getmethods__["EXAMPLECONFIG"] = lambda x: _common.UserConfig_EXAMPLECONFIG
    if _newclass:EXAMPLECONFIG = staticmethod(_common.UserConfig_EXAMPLECONFIG)
    __swig_getmethods__["JOBLISTFILE"] = lambda x: _common.UserConfig_JOBLISTFILE
    if _newclass:JOBLISTFILE = staticmethod(_common.UserConfig_JOBLISTFILE)
    DEFAULT_TIMEOUT = _common.UserConfig_DEFAULT_TIMEOUT
    __swig_getmethods__["DEFAULT_BROKER"] = lambda x: _common.UserConfig_DEFAULT_BROKER
    if _newclass:DEFAULT_BROKER = staticmethod(_common.UserConfig_DEFAULT_BROKER)
UserConfig_swigregister = _common.UserConfig_swigregister
UserConfig_swigregister(UserConfig)

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

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

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

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

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

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

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

class CertEnvLocker(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CertEnvLocker, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CertEnvLocker, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_CertEnvLocker(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_CertEnvLocker
    __del__ = lambda self : None;
CertEnvLocker_swigregister = _common.CertEnvLocker_swigregister
CertEnvLocker_swigregister(CertEnvLocker)

class ConfigEndpointMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConfigEndpointMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ConfigEndpointMap, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.ConfigEndpointMap_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.ConfigEndpointMap___nonzero__(self)
    def __bool__(self): return _common.ConfigEndpointMap___bool__(self)
    def __len__(self): return _common.ConfigEndpointMap___len__(self)
    def __getitem__(self, *args): return _common.ConfigEndpointMap___getitem__(self, *args)
    def __delitem__(self, *args): return _common.ConfigEndpointMap___delitem__(self, *args)
    def has_key(self, *args): return _common.ConfigEndpointMap_has_key(self, *args)
    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, *args): return _common.ConfigEndpointMap___contains__(self, *args)
    def key_iterator(self): return _common.ConfigEndpointMap_key_iterator(self)
    def value_iterator(self): return _common.ConfigEndpointMap_value_iterator(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 __setitem__(self, *args): return _common.ConfigEndpointMap___setitem__(self, *args)
    def __init__(self, *args): 
        this = _common.new_ConfigEndpointMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _common.ConfigEndpointMap_empty(self)
    def size(self): return _common.ConfigEndpointMap_size(self)
    def clear(self): return _common.ConfigEndpointMap_clear(self)
    def swap(self, *args): return _common.ConfigEndpointMap_swap(self, *args)
    def get_allocator(self): return _common.ConfigEndpointMap_get_allocator(self)
    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 count(self, *args): return _common.ConfigEndpointMap_count(self, *args)
    def erase(self, *args): return _common.ConfigEndpointMap_erase(self, *args)
    def find(self, *args): return _common.ConfigEndpointMap_find(self, *args)
    def lower_bound(self, *args): return _common.ConfigEndpointMap_lower_bound(self, *args)
    def upper_bound(self, *args): return _common.ConfigEndpointMap_upper_bound(self, *args)
    __swig_destroy__ = _common.delete_ConfigEndpointMap
    __del__ = lambda self : None;
ConfigEndpointMap_swigregister = _common.ConfigEndpointMap_swigregister
ConfigEndpointMap_swigregister(ConfigEndpointMap)


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

def UUID():
  return _common.UUID()
UUID = _common.UUID
class CheckSum(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CheckSum, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CheckSum, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _common.delete_CheckSum
    __del__ = lambda self : None;
    def start(self): return _common.CheckSum_start(self)
    def add(self, *args): return _common.CheckSum_add(self, *args)
    def end(self): return _common.CheckSum_end(self)
    def result(self, *args): return _common.CheckSum_result(self, *args)
    def _print(self, *args): return _common.CheckSum__print(self, *args)
    def scan(self, *args): return _common.CheckSum_scan(self, *args)
    def __nonzero__(self):
        return _common.CheckSum___nonzero__(self)
    __bool__ = __nonzero__


CheckSum_swigregister = _common.CheckSum_swigregister
CheckSum_swigregister(CheckSum)

class CRC32Sum(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CRC32Sum, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CRC32Sum, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_CRC32Sum()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_CRC32Sum
    __del__ = lambda self : None;
    def start(self): return _common.CRC32Sum_start(self)
    def add(self, *args): return _common.CRC32Sum_add(self, *args)
    def end(self): return _common.CRC32Sum_end(self)
    def result(self, *args): return _common.CRC32Sum_result(self, *args)
    def _print(self, *args): return _common.CRC32Sum__print(self, *args)
    def scan(self, *args): return _common.CRC32Sum_scan(self, *args)
    def __nonzero__(self):
        return _common.CRC32Sum___nonzero__(self)
    __bool__ = __nonzero__


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

class MD5Sum(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MD5Sum, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MD5Sum, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_MD5Sum()
        try: self.this.append(this)
        except: self.this = this
    def start(self): return _common.MD5Sum_start(self)
    def add(self, *args): return _common.MD5Sum_add(self, *args)
    def end(self): return _common.MD5Sum_end(self)
    def result(self, *args): return _common.MD5Sum_result(self, *args)
    def _print(self, *args): return _common.MD5Sum__print(self, *args)
    def scan(self, *args): return _common.MD5Sum_scan(self, *args)
    def __nonzero__(self):
        return _common.MD5Sum___nonzero__(self)
    __bool__ = __nonzero__


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

class Adler32Sum(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Adler32Sum, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Adler32Sum, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_Adler32Sum()
        try: self.this.append(this)
        except: self.this = this
    def start(self): return _common.Adler32Sum_start(self)
    def add(self, *args): return _common.Adler32Sum_add(self, *args)
    def end(self): return _common.Adler32Sum_end(self)
    def result(self, *args): return _common.Adler32Sum_result(self, *args)
    def _print(self, *args): return _common.Adler32Sum__print(self, *args)
    def scan(self, *args): return _common.Adler32Sum_scan(self, *args)
    def __nonzero__(self):
        return _common.Adler32Sum___nonzero__(self)
    __bool__ = __nonzero__


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

class CheckSumAny(CheckSum):
    __swig_setmethods__ = {}
    for _s in [CheckSum]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CheckSumAny, name, value)
    __swig_getmethods__ = {}
    for _s in [CheckSum]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CheckSumAny, name)
    __repr__ = _swig_repr
    none = _common.CheckSumAny_none
    unknown = _common.CheckSumAny_unknown
    undefined = _common.CheckSumAny_undefined
    cksum = _common.CheckSumAny_cksum
    md5 = _common.CheckSumAny_md5
    adler32 = _common.CheckSumAny_adler32
    def __init__(self, *args): 
        this = _common.new_CheckSumAny(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_CheckSumAny
    __del__ = lambda self : None;
    def start(self): return _common.CheckSumAny_start(self)
    def add(self, *args): return _common.CheckSumAny_add(self, *args)
    def end(self): return _common.CheckSumAny_end(self)
    def result(self, *args): return _common.CheckSumAny_result(self, *args)
    def _print(self, *args): return _common.CheckSumAny__print(self, *args)
    def scan(self, *args): return _common.CheckSumAny_scan(self, *args)
    def __nonzero__(self):
        return _common.CheckSumAny___nonzero__(self)
    __bool__ = __nonzero__


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

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

class JobPerfLog(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, JobPerfLog, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, JobPerfLog, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_JobPerfLog()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_JobPerfLog
    __del__ = lambda self : None;
    def SetOutput(self, *args): return _common.JobPerfLog_SetOutput(self, *args)
    def SetEnabled(self, *args): return _common.JobPerfLog_SetEnabled(self, *args)
    def GetOutput(self): return _common.JobPerfLog_GetOutput(self)
    def GetEnabled(self): return _common.JobPerfLog_GetEnabled(self)
    def Log(self, *args): return _common.JobPerfLog_Log(self, *args)
JobPerfLog_swigregister = _common.JobPerfLog_swigregister
JobPerfLog_swigregister(JobPerfLog)

class JobPerfRecord(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, JobPerfRecord, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, JobPerfRecord, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_JobPerfRecord(*args)
        try: self.this.append(this)
        except: self.this = this
    def Start(self, *args): return _common.JobPerfRecord_Start(self, *args)
    def End(self, *args): return _common.JobPerfRecord_End(self, *args)
    def Started(self): return _common.JobPerfRecord_Started(self)
    __swig_destroy__ = _common.delete_JobPerfRecord
    __del__ = lambda self : None;
JobPerfRecord_swigregister = _common.JobPerfRecord_swigregister
JobPerfRecord_swigregister(JobPerfRecord)

class ThreadDataItem(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadDataItem, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadDataItem, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_ThreadDataItem(*args)
        try: self.this.append(this)
        except: self.this = this
    def Attach(self, *args): return _common.ThreadDataItem_Attach(self, *args)
    __swig_getmethods__["Get"] = lambda x: _common.ThreadDataItem_Get
    if _newclass:Get = staticmethod(_common.ThreadDataItem_Get)
    def Dup(self): return _common.ThreadDataItem_Dup(self)
ThreadDataItem_swigregister = _common.ThreadDataItem_swigregister
ThreadDataItem_swigregister(ThreadDataItem)
thread_stacksize = cvar.thread_stacksize

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

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

class Thread(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Thread, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Thread, name)
    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
    __del__ = lambda self : None;
Thread_swigregister = _common.Thread_swigregister
Thread_swigregister(Thread)

class SimpleCondition(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleCondition, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleCondition, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_SimpleCondition()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_SimpleCondition
    __del__ = lambda self : None;
    def lock(self): return _common.SimpleCondition_lock(self)
    def unlock(self): return _common.SimpleCondition_unlock(self)
    def signal(self): return _common.SimpleCondition_signal(self)
    def signal_nonblock(self): return _common.SimpleCondition_signal_nonblock(self)
    def broadcast(self): return _common.SimpleCondition_broadcast(self)
    def wait_nonblock(self): return _common.SimpleCondition_wait_nonblock(self)
    def wait(self, *args): return _common.SimpleCondition_wait(self, *args)
    def reset(self): return _common.SimpleCondition_reset(self)
    def forceReset(self): return _common.SimpleCondition_forceReset(self)
SimpleCondition_swigregister = _common.SimpleCondition_swigregister
SimpleCondition_swigregister(SimpleCondition)

class SimpleCounter(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleCounter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleCounter, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_SimpleCounter()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_SimpleCounter
    __del__ = lambda self : None;
    def inc(self): return _common.SimpleCounter_inc(self)
    def dec(self): return _common.SimpleCounter_dec(self)
    def get(self): return _common.SimpleCounter_get(self)
    def set(self, *args): return _common.SimpleCounter_set(self, *args)
    def wait(self, *args): return _common.SimpleCounter_wait(self, *args)
    def forceReset(self): return _common.SimpleCounter_forceReset(self)
SimpleCounter_swigregister = _common.SimpleCounter_swigregister
SimpleCounter_swigregister(SimpleCounter)

class TimedMutex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TimedMutex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TimedMutex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_TimedMutex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_TimedMutex
    __del__ = lambda self : None;
    def lock(self, *args): return _common.TimedMutex_lock(self, *args)
    def trylock(self): return _common.TimedMutex_trylock(self)
    def unlock(self): return _common.TimedMutex_unlock(self)
    def forceReset(self): return _common.TimedMutex_forceReset(self)
TimedMutex_swigregister = _common.TimedMutex_swigregister
TimedMutex_swigregister(TimedMutex)

class SharedMutex(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SharedMutex, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SharedMutex, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_SharedMutex()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_SharedMutex
    __del__ = lambda self : None;
    def lockShared(self): return _common.SharedMutex_lockShared(self)
    def unlockShared(self): return _common.SharedMutex_unlockShared(self)
    def isLockShared(self): return _common.SharedMutex_isLockShared(self)
    def lockExclusive(self): return _common.SharedMutex_lockExclusive(self)
    def unlockExclusive(self): return _common.SharedMutex_unlockExclusive(self)
    def isLockExclusive(self): return _common.SharedMutex_isLockExclusive(self)
    def forceReset(self): return _common.SharedMutex_forceReset(self)
SharedMutex_swigregister = _common.SharedMutex_swigregister
SharedMutex_swigregister(SharedMutex)

class ThreadedPointerBase(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadedPointerBase, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadedPointerBase, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _common.new_ThreadedPointerBase(*args)
        try: self.this.append(this)
        except: self.this = this
    def add(self): return _common.ThreadedPointerBase_add(self)
    def rem(self): return _common.ThreadedPointerBase_rem(self)
    def ptr(self): return _common.ThreadedPointerBase_ptr(self)
    def rel(self): return _common.ThreadedPointerBase_rel(self)
    def cnt(self): return _common.ThreadedPointerBase_cnt(self)
    def lock(self): return _common.ThreadedPointerBase_lock(self)
    def unlock(self): return _common.ThreadedPointerBase_unlock(self)
    def wait(self, *args): return _common.ThreadedPointerBase_wait(self, *args)
ThreadedPointerBase_swigregister = _common.ThreadedPointerBase_swigregister
ThreadedPointerBase_swigregister(ThreadedPointerBase)

class ThreadRegistry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadRegistry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadRegistry, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_ThreadRegistry()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _common.delete_ThreadRegistry
    __del__ = lambda self : None;
    def RegisterThread(self): return _common.ThreadRegistry_RegisterThread(self)
    def UnregisterThread(self): return _common.ThreadRegistry_UnregisterThread(self)
    def WaitOrCancel(self, *args): return _common.ThreadRegistry_WaitOrCancel(self, *args)
    def WaitForExit(self, *args): return _common.ThreadRegistry_WaitForExit(self, *args)
    def RequestCancel(self): return _common.ThreadRegistry_RequestCancel(self)
    def forceReset(self): return _common.ThreadRegistry_forceReset(self)
ThreadRegistry_swigregister = _common.ThreadRegistry_swigregister
ThreadRegistry_swigregister(ThreadRegistry)


def GlibThreadInitialize():
  return _common.GlibThreadInitialize()
GlibThreadInitialize = _common.GlibThreadInitialize
class ThreadInitializer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ThreadInitializer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ThreadInitializer, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _common.new_ThreadInitializer()
        try: self.this.append(this)
        except: self.this = this
    def forceReset(self): return _common.ThreadInitializer_forceReset(self)
    def waitExit(self): return _common.ThreadInitializer_waitExit(self)
    __swig_destroy__ = _common.delete_ThreadInitializer
    __del__ = lambda self : None;
ThreadInitializer_swigregister = _common.ThreadInitializer_swigregister
ThreadInitializer_swigregister(ThreadInitializer)

class SimpleConditionList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimpleConditionList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SimpleConditionList, name)
    __repr__ = _swig_repr
    def iterator(self): return _common.SimpleConditionList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _common.SimpleConditionList___nonzero__(self)
    def __bool__(self): return _common.SimpleConditionList___bool__(self)
    def __len__(self): return _common.SimpleConditionList___len__(self)
    def pop(self): return _common.SimpleConditionList_pop(self)
    def __getslice__(self, *args): return _common.SimpleConditionList___getslice__(self, *args)
    def __setslice__(self, *args): return _common.SimpleConditionList___setslice__(self, *args)
    def __delslice__(self, *args): return _common.SimpleConditionList___delslice__(self, *args)
    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 append(self, *args): return _common.SimpleConditionList_append(self, *args)
    def empty(self): return _common.SimpleConditionList_empty(self)
    def size(self): return _common.SimpleConditionList_size(self)
    def clear(self): return _common.SimpleConditionList_clear(self)
    def swap(self, *args): return _common.SimpleConditionList_swap(self, *args)
    def get_allocator(self): return _common.SimpleConditionList_get_allocator(self)
    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 pop_back(self): return _common.SimpleConditionList_pop_back(self)
    def erase(self, *args): return _common.SimpleConditionList_erase(self, *args)
    def __init__(self, *args): 
        this = _common.new_SimpleConditionList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _common.SimpleConditionList_push_back(self, *args)
    def front(self): return _common.SimpleConditionList_front(self)
    def back(self): return _common.SimpleConditionList_back(self)
    def assign(self, *args): return _common.SimpleConditionList_assign(self, *args)
    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, *args): return _common.SimpleConditionList_push_front(self, *args)
    def remove(self, *args): return _common.SimpleConditionList_remove(self, *args)
    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, *args): return _common.SimpleConditionList_merge(self, *args)
    __swig_destroy__ = _common.delete_SimpleConditionList
    __del__ = lambda self : None;
SimpleConditionList_swigregister = _common.SimpleConditionList_swigregister
SimpleConditionList_swigregister(SimpleConditionList)