nordugrid-arc-python 5.3.0~rc1-1 / usr / lib / python2.7 / dist-packages / arc / credential.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.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 as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_credential')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_credential')
    _credential = swig_import_helper()
    del swig_import_helper
elif _swig_python_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 _swig_python_version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


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


def _swig_getattr(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("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    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, x):
        return _credential.SwigPyIterator_distance(self, x)

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

    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, n):
        return _credential.SwigPyIterator_advance(self, n)

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

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

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

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

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

    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)



from arc import common

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

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

def OpenSSLAppDataIndex(id):
    return _credential.OpenSSLAppDataIndex(id)
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, password, minsize, maxsize):
        return _credential.PasswordSource_Get(self, password, minsize, maxsize)
    __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, password, minsize, maxsize):
        return _credential.PasswordSourceNone_Get(self, password, minsize, maxsize)

    def __init__(self):
        this = _credential.new_PasswordSourceNone()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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, password):
        this = _credential.new_PasswordSourceString(password)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Get(self, password, minsize, maxsize):
        return _credential.PasswordSourceString_Get(self, password, minsize, maxsize)
    __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, password):
        this = _credential.new_PasswordSourceStream(password)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Get(self, password, minsize, maxsize):
        return _credential.PasswordSourceStream_Get(self, password, minsize, maxsize)
    __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, prompt, verify):
        this = _credential.new_PasswordSourceInteractive(prompt, verify)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def Get(self, password, minsize, maxsize):
        return _credential.PasswordSourceInteractive_Get(self, password, minsize, maxsize)
    __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, *args):
        this = _credential.new_CredentialError(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            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 __builtin__.Exception:
            self.this = this
    if _newclass:
        InitProxyCertInfo = staticmethod(_credential.Credential_InitProxyCertInfo)
    else:
        InitProxyCertInfo = _credential.Credential_InitProxyCertInfo
    if _newclass:
        IsCredentialsValid = staticmethod(_credential.Credential_IsCredentialsValid)
    else:
        IsCredentialsValid = _credential.Credential_IsCredentialsValid

    def AddCertExtObj(self, sn, oid):
        return _credential.Credential_AddCertExtObj(self, sn, oid)

    def SetSigningAlgorithm(self, *args):
        return _credential.Credential_SetSigningAlgorithm(self, *args)

    def SetKeybits(self, keybits=0):
        return _credential.Credential_SetKeybits(self, keybits)
    if _newclass:
        NoPassword = staticmethod(_credential.Credential_NoPassword)
    else:
        NoPassword = _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, arg2, is_file=True):
        return _credential.Credential_getFormat_BIO(self, arg2, is_file)

    def getFormat_str(self, source):
        return _credential.Credential_getFormat_str(self, source)

    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, proxyversion, policylang, policy, pathlength):
        return _credential.Credential_SetProxyPolicy(self, proxyversion, policylang, policy, pathlength)

    def OutputPrivatekey(self, *args):
        return _credential.Credential_OutputPrivatekey(self, *args)

    def OutputPublickey(self, content):
        return _credential.Credential_OutputPublickey(self, content)

    def OutputCertificate(self, content, is_der=False):
        return _credential.Credential_OutputCertificate(self, content, is_der)

    def OutputCertificateChain(self, content, is_der=False):
        return _credential.Credential_OutputCertificateChain(self, content, is_der)

    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, period):
        return _credential.Credential_SetLifeTime(self, period)

    def SetStartTime(self, start_time):
        return _credential.Credential_SetStartTime(self, start_time)

    def IsValid(self):
        return _credential.Credential_IsValid(self)

    def AddExtension(self, *args):
        return _credential.Credential_AddExtension(self, *args)

    def GetExtension(self, name):
        return _credential.Credential_GetExtension(self, name)

    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, dn, extfile, extsect, certfile):
        return _credential.Credential_SelfSignEECRequest(self, dn, extfile, extsect, certfile)

    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(usercfg):
    return _credential.Credential_IsCredentialsValid(usercfg)
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 __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _credential.delete_RegularExpression
    __del__ = lambda self: None

    def isOk(self):
        return _credential.RegularExpression_isOk(self)

    def hasPattern(self, str):
        return _credential.RegularExpression_hasPattern(self, str)

    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 __builtin__.Exception:
            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 __builtin__.Exception:
            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, encoded_list):
        return _credential.VOMSTrustList_AddElement(self, encoded_list)

    def AddRegex(self, reg):
        return _credential.VOMSTrustList_AddRegex(self, reg)

    def SizeChains(self):
        return _credential.VOMSTrustList_SizeChains(self)

    def SizeRegexs(self):
        return _credential.VOMSTrustList_SizeRegexs(self)

    def GetChain(self, num):
        return _credential.VOMSTrustList_GetChain(self, num)

    def GetRegex(self, num):
        return _credential.VOMSTrustList_GetRegex(self, num)
VOMSTrustList_swigregister = _credential.VOMSTrustList_swigregister
VOMSTrustList_swigregister(VOMSTrustList)


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

def createVOMSAC(codedac, issuer_cred, holder_cred, fqan, targets, attributes, voname, uri, lifetime):
    return _credential.createVOMSAC(codedac, issuer_cred, holder_cred, fqan, targets, attributes, voname, uri, lifetime)
createVOMSAC = _credential.createVOMSAC

def addVOMSAC(aclist, acorder, decodedac):
    return _credential.addVOMSAC(aclist, acorder, decodedac)
addVOMSAC = _credential.addVOMSAC

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

def VOMSDecode(data, size, j):
    return _credential.VOMSDecode(data, size, j)
VOMSDecode = _credential.VOMSDecode

def VOMSEncode(data, size, j):
    return _credential.VOMSEncode(data, size, j)
VOMSEncode = _credential.VOMSEncode

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

def VOMSFQANToFull(vo, fqan):
    return _credential.VOMSFQANToFull(vo, fqan)
VOMSFQANToFull = _credential.VOMSFQANToFull

def VOMSFQANFromFull(attribute):
    return _credential.VOMSFQANFromFull(attribute)
VOMSFQANFromFull = _credential.VOMSFQANFromFull

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 __getslice__(self, i, j):
        return _credential.VOMSACInfoVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _credential.VOMSACInfoVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _credential.VOMSACInfoVector___delslice__(self, i, j)

    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 pop(self):
        return _credential.VOMSACInfoVector_pop(self)

    def append(self, x):
        return _credential.VOMSACInfoVector_append(self, x)

    def empty(self):
        return _credential.VOMSACInfoVector_empty(self)

    def size(self):
        return _credential.VOMSACInfoVector_size(self)

    def swap(self, v):
        return _credential.VOMSACInfoVector_swap(self, v)

    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 clear(self):
        return _credential.VOMSACInfoVector_clear(self)

    def get_allocator(self):
        return _credential.VOMSACInfoVector_get_allocator(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 __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _credential.VOMSACInfoVector_push_back(self, x)

    def front(self):
        return _credential.VOMSACInfoVector_front(self)

    def back(self):
        return _credential.VOMSACInfoVector_back(self)

    def assign(self, n, x):
        return _credential.VOMSACInfoVector_assign(self, n, x)

    def resize(self, *args):
        return _credential.VOMSACInfoVector_resize(self, *args)

    def insert(self, *args):
        return _credential.VOMSACInfoVector_insert(self, *args)

    def reserve(self, n):
        return _credential.VOMSACInfoVector_reserve(self, n)

    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 __getslice__(self, i, j):
        return _credential.StringVectorVector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _credential.StringVectorVector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _credential.StringVectorVector___delslice__(self, i, j)

    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 pop(self):
        return _credential.StringVectorVector_pop(self)

    def append(self, x):
        return _credential.StringVectorVector_append(self, x)

    def empty(self):
        return _credential.StringVectorVector_empty(self)

    def size(self):
        return _credential.StringVectorVector_size(self)

    def swap(self, v):
        return _credential.StringVectorVector_swap(self, v)

    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 clear(self):
        return _credential.StringVectorVector_clear(self)

    def get_allocator(self):
        return _credential.StringVectorVector_get_allocator(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 __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _credential.StringVectorVector_push_back(self, x)

    def front(self):
        return _credential.StringVectorVector_front(self)

    def back(self):
        return _credential.StringVectorVector_back(self)

    def assign(self, n, x):
        return _credential.StringVectorVector_assign(self, n, x)

    def resize(self, *args):
        return _credential.StringVectorVector_resize(self, *args)

    def insert(self, *args):
        return _credential.StringVectorVector_insert(self, *args)

    def reserve(self, n):
        return _credential.StringVectorVector_reserve(self, n)

    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 __builtin__.Exception:
            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, options, cred, if_delegate=True):
        return _credential.CredentialStore_Retrieve(self, options, cred, if_delegate)

    def Info(self, options, respinfo):
        return _credential.CredentialStore_Info(self, options, respinfo)

    def Destroy(self, options):
        return _credential.CredentialStore_Destroy(self, options)

    def ChangePassword(self, options):
        return _credential.CredentialStore_ChangePassword(self, options)
CredentialStore_swigregister = _credential.CredentialStore_swigregister
CredentialStore_swigregister(CredentialStore)

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