nordugrid-arc-python 4.0.0-1 / usr / share / pyshared / arc / credential.py

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



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

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

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

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

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


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__ = _credential.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _credential.SwigPyIterator_value(self)
    def incr(self, n=1): return _credential.SwigPyIterator_incr(self, n)
    def decr(self, n=1): return _credential.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _credential.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _credential.SwigPyIterator_equal(self, *args)
    def copy(self): return _credential.SwigPyIterator_copy(self)
    def next(self): return _credential.SwigPyIterator_next(self)
    def __next__(self): return _credential.SwigPyIterator___next__(self)
    def previous(self): return _credential.SwigPyIterator_previous(self)
    def advance(self, *args): return _credential.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _credential.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _credential.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _credential.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _credential.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _credential.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _credential.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _credential.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 = _credential.new_StringPair(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["first"] = _credential.StringPair_first_set
    __swig_getmethods__["first"] = _credential.StringPair_first_get
    if _newclass:first = _swig_property(_credential.StringPair_first_get, _credential.StringPair_first_set)
    __swig_setmethods__["second"] = _credential.StringPair_second_set
    __swig_getmethods__["second"] = _credential.StringPair_second_get
    if _newclass:second = _swig_property(_credential.StringPair_second_get, _credential.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__ = _credential.delete_StringPair
    __del__ = lambda self : None;
StringPair_swigregister = _credential.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 _credential.StringList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _credential.StringList___nonzero__(self)
    def __bool__(self): return _credential.StringList___bool__(self)
    def __len__(self): return _credential.StringList___len__(self)
    def pop(self): return _credential.StringList_pop(self)
    def __getslice__(self, *args): return _credential.StringList___getslice__(self, *args)
    def __setslice__(self, *args): return _credential.StringList___setslice__(self, *args)
    def __delslice__(self, *args): return _credential.StringList___delslice__(self, *args)
    def __delitem__(self, *args): return _credential.StringList___delitem__(self, *args)
    def __getitem__(self, *args): return _credential.StringList___getitem__(self, *args)
    def __setitem__(self, *args): return _credential.StringList___setitem__(self, *args)
    def append(self, *args): return _credential.StringList_append(self, *args)
    def empty(self): return _credential.StringList_empty(self)
    def size(self): return _credential.StringList_size(self)
    def clear(self): return _credential.StringList_clear(self)
    def swap(self, *args): return _credential.StringList_swap(self, *args)
    def get_allocator(self): return _credential.StringList_get_allocator(self)
    def begin(self): return _credential.StringList_begin(self)
    def end(self): return _credential.StringList_end(self)
    def rbegin(self): return _credential.StringList_rbegin(self)
    def rend(self): return _credential.StringList_rend(self)
    def pop_back(self): return _credential.StringList_pop_back(self)
    def erase(self, *args): return _credential.StringList_erase(self, *args)
    def __init__(self, *args): 
        this = _credential.new_StringList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _credential.StringList_push_back(self, *args)
    def front(self): return _credential.StringList_front(self)
    def back(self): return _credential.StringList_back(self)
    def assign(self, *args): return _credential.StringList_assign(self, *args)
    def resize(self, *args): return _credential.StringList_resize(self, *args)
    def insert(self, *args): return _credential.StringList_insert(self, *args)
    def pop_front(self): return _credential.StringList_pop_front(self)
    def push_front(self, *args): return _credential.StringList_push_front(self, *args)
    def reverse(self): return _credential.StringList_reverse(self)
    __swig_destroy__ = _credential.delete_StringList
    __del__ = lambda self : None;
StringList_swigregister = _credential.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 _credential.StringSet_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _credential.StringSet___nonzero__(self)
    def __bool__(self): return _credential.StringSet___bool__(self)
    def __len__(self): return _credential.StringSet___len__(self)
    def append(self, *args): return _credential.StringSet_append(self, *args)
    def __contains__(self, *args): return _credential.StringSet___contains__(self, *args)
    def __getitem__(self, *args): return _credential.StringSet___getitem__(self, *args)
    def add(self, *args): return _credential.StringSet_add(self, *args)
    def discard(self, *args): return _credential.StringSet_discard(self, *args)
    def __init__(self, *args): 
        this = _credential.new_StringSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _credential.StringSet_empty(self)
    def size(self): return _credential.StringSet_size(self)
    def clear(self): return _credential.StringSet_clear(self)
    def swap(self, *args): return _credential.StringSet_swap(self, *args)
    def count(self, *args): return _credential.StringSet_count(self, *args)
    def begin(self): return _credential.StringSet_begin(self)
    def end(self): return _credential.StringSet_end(self)
    def rbegin(self): return _credential.StringSet_rbegin(self)
    def rend(self): return _credential.StringSet_rend(self)
    def erase(self, *args): return _credential.StringSet_erase(self, *args)
    def find(self, *args): return _credential.StringSet_find(self, *args)
    def lower_bound(self, *args): return _credential.StringSet_lower_bound(self, *args)
    def upper_bound(self, *args): return _credential.StringSet_upper_bound(self, *args)
    def equal_range(self, *args): return _credential.StringSet_equal_range(self, *args)
    def insert(self, *args): return _credential.StringSet_insert(self, *args)
    __swig_destroy__ = _credential.delete_StringSet
    __del__ = lambda self : None;
StringSet_swigregister = _credential.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 _credential.StringVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _credential.StringVector___nonzero__(self)
    def __bool__(self): return _credential.StringVector___bool__(self)
    def __len__(self): return _credential.StringVector___len__(self)
    def pop(self): return _credential.StringVector_pop(self)
    def __getslice__(self, *args): return _credential.StringVector___getslice__(self, *args)
    def __setslice__(self, *args): return _credential.StringVector___setslice__(self, *args)
    def __delslice__(self, *args): return _credential.StringVector___delslice__(self, *args)
    def __delitem__(self, *args): return _credential.StringVector___delitem__(self, *args)
    def __getitem__(self, *args): return _credential.StringVector___getitem__(self, *args)
    def __setitem__(self, *args): return _credential.StringVector___setitem__(self, *args)
    def append(self, *args): return _credential.StringVector_append(self, *args)
    def empty(self): return _credential.StringVector_empty(self)
    def size(self): return _credential.StringVector_size(self)
    def clear(self): return _credential.StringVector_clear(self)
    def swap(self, *args): return _credential.StringVector_swap(self, *args)
    def get_allocator(self): return _credential.StringVector_get_allocator(self)
    def begin(self): return _credential.StringVector_begin(self)
    def end(self): return _credential.StringVector_end(self)
    def rbegin(self): return _credential.StringVector_rbegin(self)
    def rend(self): return _credential.StringVector_rend(self)
    def pop_back(self): return _credential.StringVector_pop_back(self)
    def erase(self, *args): return _credential.StringVector_erase(self, *args)
    def __init__(self, *args): 
        this = _credential.new_StringVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _credential.StringVector_push_back(self, *args)
    def front(self): return _credential.StringVector_front(self)
    def back(self): return _credential.StringVector_back(self)
    def assign(self, *args): return _credential.StringVector_assign(self, *args)
    def resize(self, *args): return _credential.StringVector_resize(self, *args)
    def insert(self, *args): return _credential.StringVector_insert(self, *args)
    def reserve(self, *args): return _credential.StringVector_reserve(self, *args)
    def capacity(self): return _credential.StringVector_capacity(self)
    __swig_destroy__ = _credential.delete_StringVector
    __del__ = lambda self : None;
StringVector_swigregister = _credential.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 _credential.StringStringMap_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _credential.StringStringMap___nonzero__(self)
    def __bool__(self): return _credential.StringStringMap___bool__(self)
    def __len__(self): return _credential.StringStringMap___len__(self)
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args): return _credential.StringStringMap___getitem__(self, *args)
    def __delitem__(self, *args): return _credential.StringStringMap___delitem__(self, *args)
    def has_key(self, *args): return _credential.StringStringMap_has_key(self, *args)
    def keys(self): return _credential.StringStringMap_keys(self)
    def values(self): return _credential.StringStringMap_values(self)
    def items(self): return _credential.StringStringMap_items(self)
    def __contains__(self, *args): return _credential.StringStringMap___contains__(self, *args)
    def key_iterator(self): return _credential.StringStringMap_key_iterator(self)
    def value_iterator(self): return _credential.StringStringMap_value_iterator(self)
    def __setitem__(self, *args): return _credential.StringStringMap___setitem__(self, *args)
    def asdict(self): return _credential.StringStringMap_asdict(self)
    def __init__(self, *args): 
        this = _credential.new_StringStringMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _credential.StringStringMap_empty(self)
    def size(self): return _credential.StringStringMap_size(self)
    def clear(self): return _credential.StringStringMap_clear(self)
    def swap(self, *args): return _credential.StringStringMap_swap(self, *args)
    def get_allocator(self): return _credential.StringStringMap_get_allocator(self)
    def begin(self): return _credential.StringStringMap_begin(self)
    def end(self): return _credential.StringStringMap_end(self)
    def rbegin(self): return _credential.StringStringMap_rbegin(self)
    def rend(self): return _credential.StringStringMap_rend(self)
    def count(self, *args): return _credential.StringStringMap_count(self, *args)
    def erase(self, *args): return _credential.StringStringMap_erase(self, *args)
    def find(self, *args): return _credential.StringStringMap_find(self, *args)
    def lower_bound(self, *args): return _credential.StringStringMap_lower_bound(self, *args)
    def upper_bound(self, *args): return _credential.StringStringMap_upper_bound(self, *args)
    __swig_destroy__ = _credential.delete_StringStringMap
    __del__ = lambda self : None;
StringStringMap_swigregister = _credential.StringStringMap_swigregister
StringStringMap_swigregister(StringStringMap)

class StringDoubleMap(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringDoubleMap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringDoubleMap, name)
    __repr__ = _swig_repr
    def iterator(self): return _credential.StringDoubleMap_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _credential.StringDoubleMap___nonzero__(self)
    def __bool__(self): return _credential.StringDoubleMap___bool__(self)
    def __len__(self): return _credential.StringDoubleMap___len__(self)
    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __getitem__(self, *args): return _credential.StringDoubleMap___getitem__(self, *args)
    def __delitem__(self, *args): return _credential.StringDoubleMap___delitem__(self, *args)
    def has_key(self, *args): return _credential.StringDoubleMap_has_key(self, *args)
    def keys(self): return _credential.StringDoubleMap_keys(self)
    def values(self): return _credential.StringDoubleMap_values(self)
    def items(self): return _credential.StringDoubleMap_items(self)
    def __contains__(self, *args): return _credential.StringDoubleMap___contains__(self, *args)
    def key_iterator(self): return _credential.StringDoubleMap_key_iterator(self)
    def value_iterator(self): return _credential.StringDoubleMap_value_iterator(self)
    def __setitem__(self, *args): return _credential.StringDoubleMap___setitem__(self, *args)
    def asdict(self): return _credential.StringDoubleMap_asdict(self)
    def __init__(self, *args): 
        this = _credential.new_StringDoubleMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _credential.StringDoubleMap_empty(self)
    def size(self): return _credential.StringDoubleMap_size(self)
    def clear(self): return _credential.StringDoubleMap_clear(self)
    def swap(self, *args): return _credential.StringDoubleMap_swap(self, *args)
    def get_allocator(self): return _credential.StringDoubleMap_get_allocator(self)
    def begin(self): return _credential.StringDoubleMap_begin(self)
    def end(self): return _credential.StringDoubleMap_end(self)
    def rbegin(self): return _credential.StringDoubleMap_rbegin(self)
    def rend(self): return _credential.StringDoubleMap_rend(self)
    def count(self, *args): return _credential.StringDoubleMap_count(self, *args)
    def erase(self, *args): return _credential.StringDoubleMap_erase(self, *args)
    def find(self, *args): return _credential.StringDoubleMap_find(self, *args)
    def lower_bound(self, *args): return _credential.StringDoubleMap_lower_bound(self, *args)
    def upper_bound(self, *args): return _credential.StringDoubleMap_upper_bound(self, *args)
    __swig_destroy__ = _credential.delete_StringDoubleMap
    __del__ = lambda self : None;
StringDoubleMap_swigregister = _credential.StringDoubleMap_swigregister
StringDoubleMap_swigregister(StringDoubleMap)


def OpenSSLInit():
  return _credential.OpenSSLInit()
OpenSSLInit = _credential.OpenSSLInit

def HandleOpenSSLError(*args):
  return _credential.HandleOpenSSLError(*args)
HandleOpenSSLError = _credential.HandleOpenSSLError

def OpenSSLAppDataIndex(*args):
  return _credential.OpenSSLAppDataIndex(*args)
OpenSSLAppDataIndex = _credential.OpenSSLAppDataIndex
class PasswordSource(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PasswordSource, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PasswordSource, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    NO_PASSWORD = _credential.PasswordSource_NO_PASSWORD
    PASSWORD = _credential.PasswordSource_PASSWORD
    CANCEL = _credential.PasswordSource_CANCEL
    def Get(self, *args): return _credential.PasswordSource_Get(self, *args)
    __swig_destroy__ = _credential.delete_PasswordSource
    __del__ = lambda self : None;
PasswordSource_swigregister = _credential.PasswordSource_swigregister
PasswordSource_swigregister(PasswordSource)

class PasswordSourceNone(PasswordSource):
    __swig_setmethods__ = {}
    for _s in [PasswordSource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PasswordSourceNone, name, value)
    __swig_getmethods__ = {}
    for _s in [PasswordSource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PasswordSourceNone, name)
    __repr__ = _swig_repr
    def Get(self, *args): return _credential.PasswordSourceNone_Get(self, *args)
    def __init__(self): 
        this = _credential.new_PasswordSourceNone()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _credential.delete_PasswordSourceNone
    __del__ = lambda self : None;
PasswordSourceNone_swigregister = _credential.PasswordSourceNone_swigregister
PasswordSourceNone_swigregister(PasswordSourceNone)

class PasswordSourceString(PasswordSource):
    __swig_setmethods__ = {}
    for _s in [PasswordSource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PasswordSourceString, name, value)
    __swig_getmethods__ = {}
    for _s in [PasswordSource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PasswordSourceString, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _credential.new_PasswordSourceString(*args)
        try: self.this.append(this)
        except: self.this = this
    def Get(self, *args): return _credential.PasswordSourceString_Get(self, *args)
    __swig_destroy__ = _credential.delete_PasswordSourceString
    __del__ = lambda self : None;
PasswordSourceString_swigregister = _credential.PasswordSourceString_swigregister
PasswordSourceString_swigregister(PasswordSourceString)

class PasswordSourceStream(PasswordSource):
    __swig_setmethods__ = {}
    for _s in [PasswordSource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PasswordSourceStream, name, value)
    __swig_getmethods__ = {}
    for _s in [PasswordSource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PasswordSourceStream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _credential.new_PasswordSourceStream(*args)
        try: self.this.append(this)
        except: self.this = this
    def Get(self, *args): return _credential.PasswordSourceStream_Get(self, *args)
    __swig_destroy__ = _credential.delete_PasswordSourceStream
    __del__ = lambda self : None;
PasswordSourceStream_swigregister = _credential.PasswordSourceStream_swigregister
PasswordSourceStream_swigregister(PasswordSourceStream)

class PasswordSourceInteractive(PasswordSource):
    __swig_setmethods__ = {}
    for _s in [PasswordSource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PasswordSourceInteractive, name, value)
    __swig_getmethods__ = {}
    for _s in [PasswordSource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PasswordSourceInteractive, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _credential.new_PasswordSourceInteractive(*args)
        try: self.this.append(this)
        except: self.this = this
    def Get(self, *args): return _credential.PasswordSourceInteractive_Get(self, *args)
    __swig_destroy__ = _credential.delete_PasswordSourceInteractive
    __del__ = lambda self : None;
PasswordSourceInteractive_swigregister = _credential.PasswordSourceInteractive_swigregister
PasswordSourceInteractive_swigregister(PasswordSourceInteractive)

class CredentialError(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CredentialError, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CredentialError, name)
    __repr__ = _swig_repr
    def __init__(self, what=""): 
        this = _credential.new_CredentialError(what)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _credential.delete_CredentialError
    __del__ = lambda self : None;
CredentialError_swigregister = _credential.CredentialError_swigregister
CredentialError_swigregister(CredentialError)

CRED_PEM = _credential.CRED_PEM
CRED_DER = _credential.CRED_DER
CRED_PKCS = _credential.CRED_PKCS
CRED_UNKNOWN = _credential.CRED_UNKNOWN
SIGN_DEFAULT = _credential.SIGN_DEFAULT
SIGN_SHA1 = _credential.SIGN_SHA1
SIGN_SHA224 = _credential.SIGN_SHA224
SIGN_SHA256 = _credential.SIGN_SHA256
SIGN_SHA384 = _credential.SIGN_SHA384
SIGN_SHA512 = _credential.SIGN_SHA512
class Credential(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Credential, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Credential, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _credential.delete_Credential
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _credential.new_Credential(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_getmethods__["InitProxyCertInfo"] = lambda x: _credential.Credential_InitProxyCertInfo
    if _newclass:InitProxyCertInfo = staticmethod(_credential.Credential_InitProxyCertInfo)
    __swig_getmethods__["IsCredentialsValid"] = lambda x: _credential.Credential_IsCredentialsValid
    if _newclass:IsCredentialsValid = staticmethod(_credential.Credential_IsCredentialsValid)
    def AddCertExtObj(self, *args): return _credential.Credential_AddCertExtObj(self, *args)
    def SetSigningAlgorithm(self, *args): return _credential.Credential_SetSigningAlgorithm(self, *args)
    def SetKeybits(self, keybits=0): return _credential.Credential_SetKeybits(self, keybits)
    __swig_getmethods__["NoPassword"] = lambda x: _credential.Credential_NoPassword
    if _newclass:NoPassword = staticmethod(_credential.Credential_NoPassword)
    def LogError(self): return _credential.Credential_LogError(self)
    def GetVerification(self): return _credential.Credential_GetVerification(self)
    def GetPrivKey(self): return _credential.Credential_GetPrivKey(self)
    def GetPubKey(self): return _credential.Credential_GetPubKey(self)
    def GetCert(self): return _credential.Credential_GetCert(self)
    def GetCertReq(self): return _credential.Credential_GetCertReq(self)
    def GetCertChain(self): return _credential.Credential_GetCertChain(self)
    def GetCertNumofChain(self): return _credential.Credential_GetCertNumofChain(self)
    def getFormat_BIO(self, *args): return _credential.Credential_getFormat_BIO(self, *args)
    def getFormat_str(self, *args): return _credential.Credential_getFormat_str(self, *args)
    def GetDN(self): return _credential.Credential_GetDN(self)
    def GetIdentityName(self): return _credential.Credential_GetIdentityName(self)
    def GetType(self): return _credential.Credential_GetType(self)
    def GetIssuerName(self): return _credential.Credential_GetIssuerName(self)
    def GetCAName(self): return _credential.Credential_GetCAName(self)
    def GetSigningAlgorithm(self): return _credential.Credential_GetSigningAlgorithm(self)
    def GetKeybits(self): return _credential.Credential_GetKeybits(self)
    def GetProxyPolicy(self): return _credential.Credential_GetProxyPolicy(self)
    def SetProxyPolicy(self, *args): return _credential.Credential_SetProxyPolicy(self, *args)
    def OutputPrivatekey(self, *args): return _credential.Credential_OutputPrivatekey(self, *args)
    def OutputPublickey(self, *args): return _credential.Credential_OutputPublickey(self, *args)
    def OutputCertificate(self, *args): return _credential.Credential_OutputCertificate(self, *args)
    def OutputCertificateChain(self, *args): return _credential.Credential_OutputCertificateChain(self, *args)
    def GetLifeTime(self): return _credential.Credential_GetLifeTime(self)
    def GetStartTime(self): return _credential.Credential_GetStartTime(self)
    def GetEndTime(self): return _credential.Credential_GetEndTime(self)
    def SetLifeTime(self, *args): return _credential.Credential_SetLifeTime(self, *args)
    def SetStartTime(self, *args): return _credential.Credential_SetStartTime(self, *args)
    def IsValid(self): return _credential.Credential_IsValid(self)
    def AddExtension(self, *args): return _credential.Credential_AddExtension(self, *args)
    def GetExtension(self, *args): return _credential.Credential_GetExtension(self, *args)
    def GenerateEECRequest(self, *args): return _credential.Credential_GenerateEECRequest(self, *args)
    def GenerateRequest(self, *args): return _credential.Credential_GenerateRequest(self, *args)
    def InquireRequest(self, *args): return _credential.Credential_InquireRequest(self, *args)
    def SignRequest(self, *args): return _credential.Credential_SignRequest(self, *args)
    def SelfSignEECRequest(self, *args): return _credential.Credential_SelfSignEECRequest(self, *args)
    def SignEECRequest(self, *args): return _credential.Credential_SignEECRequest(self, *args)
Credential_swigregister = _credential.Credential_swigregister
Credential_swigregister(Credential)
cvar = _credential.cvar
CredentialLogger = cvar.CredentialLogger

def Credential_InitProxyCertInfo():
  return _credential.Credential_InitProxyCertInfo()
Credential_InitProxyCertInfo = _credential.Credential_InitProxyCertInfo

def Credential_IsCredentialsValid(*args):
  return _credential.Credential_IsCredentialsValid(*args)
Credential_IsCredentialsValid = _credential.Credential_IsCredentialsValid

def Credential_NoPassword():
  return _credential.Credential_NoPassword()
Credential_NoPassword = _credential.Credential_NoPassword

class RegularExpression(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RegularExpression, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RegularExpression, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _credential.new_RegularExpression(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _credential.delete_RegularExpression
    __del__ = lambda self : None;
    def isOk(self): return _credential.RegularExpression_isOk(self)
    def hasPattern(self, *args): return _credential.RegularExpression_hasPattern(self, *args)
    def match(self, *args): return _credential.RegularExpression_match(self, *args)
    def getPattern(self): return _credential.RegularExpression_getPattern(self)
RegularExpression_swigregister = _credential.RegularExpression_swigregister
RegularExpression_swigregister(RegularExpression)

class VOMSACInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VOMSACInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VOMSACInfo, name)
    __repr__ = _swig_repr
    Success = _credential.VOMSACInfo_Success
    CAUnknown = _credential.VOMSACInfo_CAUnknown
    CertRevoked = _credential.VOMSACInfo_CertRevoked
    LSCFailed = _credential.VOMSACInfo_LSCFailed
    TrustFailed = _credential.VOMSACInfo_TrustFailed
    X509ParsingFailed = _credential.VOMSACInfo_X509ParsingFailed
    ACParsingFailed = _credential.VOMSACInfo_ACParsingFailed
    InternalParsingFailed = _credential.VOMSACInfo_InternalParsingFailed
    TimeValidFailed = _credential.VOMSACInfo_TimeValidFailed
    IsCritical = _credential.VOMSACInfo_IsCritical
    ParsingError = _credential.VOMSACInfo_ParsingError
    ValidationError = _credential.VOMSACInfo_ValidationError
    Error = _credential.VOMSACInfo_Error
    __swig_setmethods__["voname"] = _credential.VOMSACInfo_voname_set
    __swig_getmethods__["voname"] = _credential.VOMSACInfo_voname_get
    if _newclass:voname = _swig_property(_credential.VOMSACInfo_voname_get, _credential.VOMSACInfo_voname_set)
    __swig_setmethods__["holder"] = _credential.VOMSACInfo_holder_set
    __swig_getmethods__["holder"] = _credential.VOMSACInfo_holder_get
    if _newclass:holder = _swig_property(_credential.VOMSACInfo_holder_get, _credential.VOMSACInfo_holder_set)
    __swig_setmethods__["issuer"] = _credential.VOMSACInfo_issuer_set
    __swig_getmethods__["issuer"] = _credential.VOMSACInfo_issuer_get
    if _newclass:issuer = _swig_property(_credential.VOMSACInfo_issuer_get, _credential.VOMSACInfo_issuer_set)
    __swig_setmethods__["target"] = _credential.VOMSACInfo_target_set
    __swig_getmethods__["target"] = _credential.VOMSACInfo_target_get
    if _newclass:target = _swig_property(_credential.VOMSACInfo_target_get, _credential.VOMSACInfo_target_set)
    __swig_setmethods__["attributes"] = _credential.VOMSACInfo_attributes_set
    __swig_getmethods__["attributes"] = _credential.VOMSACInfo_attributes_get
    if _newclass:attributes = _swig_property(_credential.VOMSACInfo_attributes_get, _credential.VOMSACInfo_attributes_set)
    __swig_setmethods__["_from"] = _credential.VOMSACInfo__from_set
    __swig_getmethods__["_from"] = _credential.VOMSACInfo__from_get
    if _newclass:_from = _swig_property(_credential.VOMSACInfo__from_get, _credential.VOMSACInfo__from_set)
    __swig_setmethods__["till"] = _credential.VOMSACInfo_till_set
    __swig_getmethods__["till"] = _credential.VOMSACInfo_till_get
    if _newclass:till = _swig_property(_credential.VOMSACInfo_till_get, _credential.VOMSACInfo_till_set)
    __swig_setmethods__["status"] = _credential.VOMSACInfo_status_set
    __swig_getmethods__["status"] = _credential.VOMSACInfo_status_get
    if _newclass:status = _swig_property(_credential.VOMSACInfo_status_get, _credential.VOMSACInfo_status_set)
    def __init__(self): 
        this = _credential.new_VOMSACInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _credential.delete_VOMSACInfo
    __del__ = lambda self : None;
VOMSACInfo_swigregister = _credential.VOMSACInfo_swigregister
VOMSACInfo_swigregister(VOMSACInfo)

class VOMSTrustList(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VOMSTrustList, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VOMSTrustList, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _credential.new_VOMSTrustList(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _credential.delete_VOMSTrustList
    __del__ = lambda self : None;
    def AddChain(self, *args): return _credential.VOMSTrustList_AddChain(self, *args)
    def AddElement(self, *args): return _credential.VOMSTrustList_AddElement(self, *args)
    def AddRegex(self, *args): return _credential.VOMSTrustList_AddRegex(self, *args)
    def SizeChains(self): return _credential.VOMSTrustList_SizeChains(self)
    def SizeRegexs(self): return _credential.VOMSTrustList_SizeRegexs(self)
    def GetChain(self, *args): return _credential.VOMSTrustList_GetChain(self, *args)
    def GetRegex(self, *args): return _credential.VOMSTrustList_GetRegex(self, *args)
VOMSTrustList_swigregister = _credential.VOMSTrustList_swigregister
VOMSTrustList_swigregister(VOMSTrustList)


def InitVOMSAttribute():
  return _credential.InitVOMSAttribute()
InitVOMSAttribute = _credential.InitVOMSAttribute

def createVOMSAC(*args):
  return _credential.createVOMSAC(*args)
createVOMSAC = _credential.createVOMSAC

def addVOMSAC(*args):
  return _credential.addVOMSAC(*args)
addVOMSAC = _credential.addVOMSAC

def parseVOMSAC(*args):
  return _credential.parseVOMSAC(*args)
parseVOMSAC = _credential.parseVOMSAC

def VOMSDecode(*args):
  return _credential.VOMSDecode(*args)
VOMSDecode = _credential.VOMSDecode

def VOMSEncode(*args):
  return _credential.VOMSEncode(*args)
VOMSEncode = _credential.VOMSEncode

def getCredentialProperty(*args):
  return _credential.getCredentialProperty(*args)
getCredentialProperty = _credential.getCredentialProperty

def VOMSFQANToFull(*args):
  return _credential.VOMSFQANToFull(*args)
VOMSFQANToFull = _credential.VOMSFQANToFull

def VOMSACSeqEncode(*args):
  return _credential.VOMSACSeqEncode(*args)
VOMSACSeqEncode = _credential.VOMSACSeqEncode
class VOMSACInfoVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VOMSACInfoVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VOMSACInfoVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _credential.VOMSACInfoVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _credential.VOMSACInfoVector___nonzero__(self)
    def __bool__(self): return _credential.VOMSACInfoVector___bool__(self)
    def __len__(self): return _credential.VOMSACInfoVector___len__(self)
    def pop(self): return _credential.VOMSACInfoVector_pop(self)
    def __getslice__(self, *args): return _credential.VOMSACInfoVector___getslice__(self, *args)
    def __setslice__(self, *args): return _credential.VOMSACInfoVector___setslice__(self, *args)
    def __delslice__(self, *args): return _credential.VOMSACInfoVector___delslice__(self, *args)
    def __delitem__(self, *args): return _credential.VOMSACInfoVector___delitem__(self, *args)
    def __getitem__(self, *args): return _credential.VOMSACInfoVector___getitem__(self, *args)
    def __setitem__(self, *args): return _credential.VOMSACInfoVector___setitem__(self, *args)
    def append(self, *args): return _credential.VOMSACInfoVector_append(self, *args)
    def empty(self): return _credential.VOMSACInfoVector_empty(self)
    def size(self): return _credential.VOMSACInfoVector_size(self)
    def clear(self): return _credential.VOMSACInfoVector_clear(self)
    def swap(self, *args): return _credential.VOMSACInfoVector_swap(self, *args)
    def get_allocator(self): return _credential.VOMSACInfoVector_get_allocator(self)
    def begin(self): return _credential.VOMSACInfoVector_begin(self)
    def end(self): return _credential.VOMSACInfoVector_end(self)
    def rbegin(self): return _credential.VOMSACInfoVector_rbegin(self)
    def rend(self): return _credential.VOMSACInfoVector_rend(self)
    def pop_back(self): return _credential.VOMSACInfoVector_pop_back(self)
    def erase(self, *args): return _credential.VOMSACInfoVector_erase(self, *args)
    def __init__(self, *args): 
        this = _credential.new_VOMSACInfoVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _credential.VOMSACInfoVector_push_back(self, *args)
    def front(self): return _credential.VOMSACInfoVector_front(self)
    def back(self): return _credential.VOMSACInfoVector_back(self)
    def assign(self, *args): return _credential.VOMSACInfoVector_assign(self, *args)
    def resize(self, *args): return _credential.VOMSACInfoVector_resize(self, *args)
    def insert(self, *args): return _credential.VOMSACInfoVector_insert(self, *args)
    def reserve(self, *args): return _credential.VOMSACInfoVector_reserve(self, *args)
    def capacity(self): return _credential.VOMSACInfoVector_capacity(self)
    __swig_destroy__ = _credential.delete_VOMSACInfoVector
    __del__ = lambda self : None;
VOMSACInfoVector_swigregister = _credential.VOMSACInfoVector_swigregister
VOMSACInfoVector_swigregister(VOMSACInfoVector)

class StringVectorVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringVectorVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringVectorVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _credential.StringVectorVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _credential.StringVectorVector___nonzero__(self)
    def __bool__(self): return _credential.StringVectorVector___bool__(self)
    def __len__(self): return _credential.StringVectorVector___len__(self)
    def pop(self): return _credential.StringVectorVector_pop(self)
    def __getslice__(self, *args): return _credential.StringVectorVector___getslice__(self, *args)
    def __setslice__(self, *args): return _credential.StringVectorVector___setslice__(self, *args)
    def __delslice__(self, *args): return _credential.StringVectorVector___delslice__(self, *args)
    def __delitem__(self, *args): return _credential.StringVectorVector___delitem__(self, *args)
    def __getitem__(self, *args): return _credential.StringVectorVector___getitem__(self, *args)
    def __setitem__(self, *args): return _credential.StringVectorVector___setitem__(self, *args)
    def append(self, *args): return _credential.StringVectorVector_append(self, *args)
    def empty(self): return _credential.StringVectorVector_empty(self)
    def size(self): return _credential.StringVectorVector_size(self)
    def clear(self): return _credential.StringVectorVector_clear(self)
    def swap(self, *args): return _credential.StringVectorVector_swap(self, *args)
    def get_allocator(self): return _credential.StringVectorVector_get_allocator(self)
    def begin(self): return _credential.StringVectorVector_begin(self)
    def end(self): return _credential.StringVectorVector_end(self)
    def rbegin(self): return _credential.StringVectorVector_rbegin(self)
    def rend(self): return _credential.StringVectorVector_rend(self)
    def pop_back(self): return _credential.StringVectorVector_pop_back(self)
    def erase(self, *args): return _credential.StringVectorVector_erase(self, *args)
    def __init__(self, *args): 
        this = _credential.new_StringVectorVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _credential.StringVectorVector_push_back(self, *args)
    def front(self): return _credential.StringVectorVector_front(self)
    def back(self): return _credential.StringVectorVector_back(self)
    def assign(self, *args): return _credential.StringVectorVector_assign(self, *args)
    def resize(self, *args): return _credential.StringVectorVector_resize(self, *args)
    def insert(self, *args): return _credential.StringVectorVector_insert(self, *args)
    def reserve(self, *args): return _credential.StringVectorVector_reserve(self, *args)
    def capacity(self): return _credential.StringVectorVector_capacity(self)
    __swig_destroy__ = _credential.delete_StringVectorVector
    __del__ = lambda self : None;
StringVectorVector_swigregister = _credential.StringVectorVector_swigregister
StringVectorVector_swigregister(StringVectorVector)

class CredentialStore(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CredentialStore, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CredentialStore, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _credential.new_CredentialStore(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _credential.delete_CredentialStore
    __del__ = lambda self : None;
    def __nonzero__(self):
        return _credential.CredentialStore___nonzero__(self)
    __bool__ = __nonzero__


    def Store(self, *args): return _credential.CredentialStore_Store(self, *args)
    def Retrieve(self, *args): return _credential.CredentialStore_Retrieve(self, *args)
    def Info(self, *args): return _credential.CredentialStore_Info(self, *args)
    def Destroy(self, *args): return _credential.CredentialStore_Destroy(self, *args)
    def ChangePassword(self, *args): return _credential.CredentialStore_ChangePassword(self, *args)
CredentialStore_swigregister = _credential.CredentialStore_swigregister
CredentialStore_swigregister(CredentialStore)

# This file is compatible with both classic and new-style classes.