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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _message
else:
    from arc import _message

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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


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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _message.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _message:
_message.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
from arc import loader
STATUS_UNDEFINED = _message.STATUS_UNDEFINED
STATUS_OK = _message.STATUS_OK
GENERIC_ERROR = _message.GENERIC_ERROR
PARSING_ERROR = _message.PARSING_ERROR
PROTOCOL_RECOGNIZED_ERROR = _message.PROTOCOL_RECOGNIZED_ERROR
UNKNOWN_SERVICE_ERROR = _message.UNKNOWN_SERVICE_ERROR
BUSY_ERROR = _message.BUSY_ERROR
SESSION_CLOSE = _message.SESSION_CLOSE

def string(kind):
    return _message.string(kind)
class MCC_Status(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _message.MCC_Status_swiginit(self, _message.new_MCC_Status(*args))

    def isOk(self):
        return _message.MCC_Status_isOk(self)

    def getKind(self):
        return _message.MCC_Status_getKind(self)

    def getOrigin(self):
        return _message.MCC_Status_getOrigin(self)

    def getExplanation(self):
        return _message.MCC_Status_getExplanation(self)

    def __str__(self):
        return _message.MCC_Status___str__(self)

    def __nonzero__(self):
        return _message.MCC_Status___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _message.delete_MCC_Status

# Register MCC_Status in _message:
_message.MCC_Status_swigregister(MCC_Status)
class AttributeIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.AttributeIterator_swiginit(self, _message.new_AttributeIterator())

    def __ref__(self):
        return _message.AttributeIterator___ref__(self)

    def __deref__(self):
        return _message.AttributeIterator___deref__(self)

    def key(self):
        return _message.AttributeIterator_key(self)

    def next(self, *args):
        return _message.AttributeIterator_next(self, *args)

    def hasMore(self):
        return _message.AttributeIterator_hasMore(self)
    __swig_destroy__ = _message.delete_AttributeIterator

# Register AttributeIterator in _message:
_message.AttributeIterator_swigregister(AttributeIterator)
class MessageAttributes(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MessageAttributes_swiginit(self, _message.new_MessageAttributes())

    def set(self, key, value):
        return _message.MessageAttributes_set(self, key, value)

    def add(self, key, value):
        return _message.MessageAttributes_add(self, key, value)

    def removeAll(self, key):
        return _message.MessageAttributes_removeAll(self, key)

    def remove(self, key, value):
        return _message.MessageAttributes_remove(self, key, value)

    def count(self, key):
        return _message.MessageAttributes_count(self, key)

    def get(self, key):
        return _message.MessageAttributes_get(self, key)

    def getAll(self, *args):
        val = _message.MessageAttributes_getAll(self, *args)

        d = dict()
        while val.hasMore():
            d[val.key()] = val.__ref__()
            val.next()
        return d


        return val

    __swig_destroy__ = _message.delete_MessageAttributes

# Register MessageAttributes in _message:
_message.MessageAttributes_swigregister(MessageAttributes)
class SecAttrFormat(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _message.SecAttrFormat_swiginit(self, _message.new_SecAttrFormat(*args))

    def __eq__(self, *args):
        return _message.SecAttrFormat___eq__(self, *args)

    def __ne__(self, *args):
        return _message.SecAttrFormat___ne__(self, *args)
    __swig_destroy__ = _message.delete_SecAttrFormat

# Register SecAttrFormat in _message:
_message.SecAttrFormat_swigregister(SecAttrFormat)
class SecAttr(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    UNDEFINED = property(_message.SecAttr_UNDEFINED_get, _message.SecAttr_UNDEFINED_set)
    ARCAuth = property(_message.SecAttr_ARCAuth_get, _message.SecAttr_ARCAuth_set)
    XACML = property(_message.SecAttr_XACML_get, _message.SecAttr_XACML_set)
    SAML = property(_message.SecAttr_SAML_get, _message.SecAttr_SAML_set)
    GACL = property(_message.SecAttr_GACL_get, _message.SecAttr_GACL_set)

    def __init__(self):
        _message.SecAttr_swiginit(self, _message.new_SecAttr())
    __swig_destroy__ = _message.delete_SecAttr

    def __eq__(self, b):
        return _message.SecAttr___eq__(self, b)

    def __ne__(self, b):
        return _message.SecAttr___ne__(self, b)

    def __nonzero__(self):
        return _message.SecAttr___nonzero__(self)
    __bool__ = __nonzero__



    def Export(self, *args):
        return _message.SecAttr_Export(self, *args)

    def Import(self, *args):
        return _message.SecAttr_Import(self, *args)

    def get(self, id):
        return _message.SecAttr_get(self, id)

    def getAll(self, id):
        return _message.SecAttr_getAll(self, id)

# Register SecAttr in _message:
_message.SecAttr_swigregister(SecAttr)
cvar = _message.cvar

class MultiSecAttr(SecAttr):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MultiSecAttr_swiginit(self, _message.new_MultiSecAttr())
    __swig_destroy__ = _message.delete_MultiSecAttr

    def __nonzero__(self):
        return _message.MultiSecAttr___nonzero__(self)
    __bool__ = __nonzero__



    def Export(self, format, val):
        return _message.MultiSecAttr_Export(self, format, val)

    def Import(self, format, val):
        return _message.MultiSecAttr_Import(self, format, val)

# Register MultiSecAttr in _message:
_message.MultiSecAttr_swigregister(MultiSecAttr)
class MessageAuth(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MessageAuth_swiginit(self, _message.new_MessageAuth())
    __swig_destroy__ = _message.delete_MessageAuth

    def set(self, key, value):
        return _message.MessageAuth_set(self, key, value)

    def remove(self, key):
        return _message.MessageAuth_remove(self, key)

    def get(self, key):
        return _message.MessageAuth_get(self, key)

    def Export(self, format, val):

        x = XMLNode("<dummy/>")
        args = args[:-1] + (args[-1].fget(), x)



        val = _message.MessageAuth_Export(self, format, val)

        return x


        return val


    def Filter(self, selected_keys, rejected_keys):
        return _message.MessageAuth_Filter(self, selected_keys, rejected_keys)

# Register MessageAuth in _message:
_message.MessageAuth_swigregister(MessageAuth)
class MessagePayload(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MessagePayload_swiginit(self, _message.new_MessagePayload())
    __swig_destroy__ = _message.delete_MessagePayload

    def Failure(self):
        return _message.MessagePayload_Failure(self)

# Register MessagePayload in _message:
_message.MessagePayload_swigregister(MessagePayload)
class MessageContextElement(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MessageContextElement_swiginit(self, _message.new_MessageContextElement())
    __swig_destroy__ = _message.delete_MessageContextElement

# Register MessageContextElement in _message:
_message.MessageContextElement_swigregister(MessageContextElement)
class MessageContext(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MessageContext_swiginit(self, _message.new_MessageContext())
    __swig_destroy__ = _message.delete_MessageContext

    def Add(self, name, element):
        return _message.MessageContext_Add(self, name, element)

# Register MessageContext in _message:
_message.MessageContext_swigregister(MessageContext)
class MessageAuthContext(MessageAuth):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MessageAuthContext_swiginit(self, _message.new_MessageAuthContext())
    __swig_destroy__ = _message.delete_MessageAuthContext

# Register MessageAuthContext in _message:
_message.MessageAuthContext_swigregister(MessageAuthContext)
class Message(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _message.Message_swiginit(self, _message.new_Message(*args))
    __swig_destroy__ = _message.delete_Message

    def Payload(self, *args):
        return _message.Message_Payload(self, *args)

    def Attributes(self, *args):
        return _message.Message_Attributes(self, *args)

    def Auth(self, *args):
        return _message.Message_Auth(self, *args)

    def Context(self, *args):
        return _message.Message_Context(self, *args)

    def AuthContext(self, *args):
        return _message.Message_AuthContext(self, *args)

# Register Message in _message:
_message.Message_swigregister(Message)
class MCCInterface(loader.Plugin):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def process(self, request, response):
        return _message.MCCInterface_process(self, request, response)
    __swig_destroy__ = _message.delete_MCCInterface

# Register MCCInterface in _message:
_message.MCCInterface_swigregister(MCCInterface)
class MCC(MCCInterface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, arg2, arg):
        _message.MCC_swiginit(self, _message.new_MCC(arg2, arg))
    __swig_destroy__ = _message.delete_MCC

    def Next(self, *args):
        return _message.MCC_Next(self, *args)

    def AddSecHandler(self, *args):
        return _message.MCC_AddSecHandler(self, *args)

    def Unlink(self):
        return _message.MCC_Unlink(self)

    def process(self, arg2, arg3):
        return _message.MCC_process(self, arg2, arg3)

# Register MCC in _message:
_message.MCC_swigregister(MCC)
class MCCConfig(common.BaseConfig):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.MCCConfig_swiginit(self, _message.new_MCCConfig())
    __swig_destroy__ = _message.delete_MCCConfig

    def MakeConfig(self, cfg):
        return _message.MCCConfig_MakeConfig(self, cfg)

# Register MCCConfig in _message:
_message.MCCConfig_swigregister(MCCConfig)
MCCPluginKind = _message.MCCPluginKind
class MCCPluginArgument(loader.PluginArgument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, config, context):
        _message.MCCPluginArgument_swiginit(self, _message.new_MCCPluginArgument(config, context))
    __swig_destroy__ = _message.delete_MCCPluginArgument

# Register MCCPluginArgument in _message:
_message.MCCPluginArgument_swigregister(MCCPluginArgument)
class PayloadRawInterface(MessagePayload):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Content(self, pos=-1):
        return _message.PayloadRawInterface_Content(self, pos)

    def Size(self):
        return _message.PayloadRawInterface_Size(self)

    def Insert(self, *args):
        return _message.PayloadRawInterface_Insert(self, *args)

    def Buffer(self, num):
        return _message.PayloadRawInterface_Buffer(self, num)

    def BufferSize(self, num):
        return _message.PayloadRawInterface_BufferSize(self, num)

    def BufferPos(self, num):
        return _message.PayloadRawInterface_BufferPos(self, num)

    def Truncate(self, size):
        return _message.PayloadRawInterface_Truncate(self, size)

# Register PayloadRawInterface in _message:
_message.PayloadRawInterface_swigregister(PayloadRawInterface)
class PayloadRawBuf(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    data = property(_message.PayloadRawBuf_data_get, _message.PayloadRawBuf_data_set)
    size = property(_message.PayloadRawBuf_size_get, _message.PayloadRawBuf_size_set)
    length = property(_message.PayloadRawBuf_length_get, _message.PayloadRawBuf_length_set)
    allocated = property(_message.PayloadRawBuf_allocated_get, _message.PayloadRawBuf_allocated_set)

    def __init__(self):
        _message.PayloadRawBuf_swiginit(self, _message.new_PayloadRawBuf())
    __swig_destroy__ = _message.delete_PayloadRawBuf

# Register PayloadRawBuf in _message:
_message.PayloadRawBuf_swigregister(PayloadRawBuf)
class PayloadRaw(PayloadRawInterface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self):
        _message.PayloadRaw_swiginit(self, _message.new_PayloadRaw())
    __swig_destroy__ = _message.delete_PayloadRaw

    def Content(self, pos=-1):
        return _message.PayloadRaw_Content(self, pos)

    def Size(self):
        return _message.PayloadRaw_Size(self)

    def Insert(self, *args):
        return _message.PayloadRaw_Insert(self, *args)

    def Buffer(self, num=0):
        return _message.PayloadRaw_Buffer(self, num)

    def BufferSize(self, num=0):
        return _message.PayloadRaw_BufferSize(self, num)

    def BufferPos(self, num=0):
        return _message.PayloadRaw_BufferPos(self, num)

    def Truncate(self, size):
        return _message.PayloadRaw_Truncate(self, size)

# Register PayloadRaw in _message:
_message.PayloadRaw_swigregister(PayloadRaw)

def ContentFromPayload(payload):
    return _message.ContentFromPayload(payload)
class SOAPFault(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    undefined = _message.SOAPFault_undefined
    unknown = _message.SOAPFault_unknown
    VersionMismatch = _message.SOAPFault_VersionMismatch
    MustUnderstand = _message.SOAPFault_MustUnderstand
    Sender = _message.SOAPFault_Sender
    Receiver = _message.SOAPFault_Receiver
    DataEncodingUnknown = _message.SOAPFault_DataEncodingUnknown

    def __init__(self, *args):
        _message.SOAPFault_swiginit(self, _message.new_SOAPFault(*args))

    def __nonzero__(self):
        return _message.SOAPFault___nonzero__(self)
    __bool__ = __nonzero__



    def Code(self, *args):
        return _message.SOAPFault_Code(self, *args)

    def Subcode(self, *args):
        return _message.SOAPFault_Subcode(self, *args)

    def Reason(self, *args):
        return _message.SOAPFault_Reason(self, *args)

    def Node(self, *args):
        return _message.SOAPFault_Node(self, *args)

    def Role(self, *args):
        return _message.SOAPFault_Role(self, *args)

    def Detail(self, create=False):
        return _message.SOAPFault_Detail(self, create)

    @staticmethod
    def MakeSOAPFault(*args):
        return _message.SOAPFault_MakeSOAPFault(*args)
    __swig_destroy__ = _message.delete_SOAPFault

# Register SOAPFault in _message:
_message.SOAPFault_swigregister(SOAPFault)
class SOAPEnvelope(common.XMLNode):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Version_1_1 = _message.SOAPEnvelope_Version_1_1
    Version_1_2 = _message.SOAPEnvelope_Version_1_2

    def __init__(self, *args):
        _message.SOAPEnvelope_swiginit(self, _message.new_SOAPEnvelope(*args))
    __swig_destroy__ = _message.delete_SOAPEnvelope

    def New(self):
        return _message.SOAPEnvelope_New(self)

    def Swap(self, *args):
        return _message.SOAPEnvelope_Swap(self, *args)

    def Namespaces(self, *args):
        return _message.SOAPEnvelope_Namespaces(self, *args)

    def GetXML(self, user_friendly=False):
        return _message.SOAPEnvelope_GetXML(self, user_friendly)

    def Header(self):
        return _message.SOAPEnvelope_Header(self)

    def Body(self):
        return _message.SOAPEnvelope_Body(self)

    def IsFault(self):
        return _message.SOAPEnvelope_IsFault(self)

    def Fault(self):
        return _message.SOAPEnvelope_Fault(self)

    def Version(self):
        return _message.SOAPEnvelope_Version(self)

# Register SOAPEnvelope in _message:
_message.SOAPEnvelope_swigregister(SOAPEnvelope)
class SOAPMessage(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _message.SOAPMessage_swiginit(self, _message.new_SOAPMessage(*args))
    __swig_destroy__ = _message.delete_SOAPMessage

    def Payload(self, *args):
        return _message.SOAPMessage_Payload(self, *args)

    def Attributes(self, *args):
        return _message.SOAPMessage_Attributes(self, *args)

    def Auth(self, *args):
        return _message.SOAPMessage_Auth(self, *args)

    def Context(self, *args):
        return _message.SOAPMessage_Context(self, *args)

# Register SOAPMessage in _message:
_message.SOAPMessage_swigregister(SOAPMessage)
class PayloadSOAP(SOAPEnvelope, MessagePayload):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        _message.PayloadSOAP_swiginit(self, _message.new_PayloadSOAP(*args))
    __swig_destroy__ = _message.delete_PayloadSOAP

# Register PayloadSOAP in _message:
_message.PayloadSOAP_swigregister(PayloadSOAP)
class PayloadStreamInterface(MessagePayload):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def Get(self, *args):
        return _message.PayloadStreamInterface_Get(self, *args)

    def Put(self, *args):
        return _message.PayloadStreamInterface_Put(self, *args)

    def __nonzero__(self):
        return _message.PayloadStreamInterface___nonzero__(self)
    __bool__ = __nonzero__



    def Timeout(self, *args):
        return _message.PayloadStreamInterface_Timeout(self, *args)

    def Pos(self):
        return _message.PayloadStreamInterface_Pos(self)

    def Size(self):
        return _message.PayloadStreamInterface_Size(self)

    def Limit(self):
        return _message.PayloadStreamInterface_Limit(self)

# Register PayloadStreamInterface in _message:
_message.PayloadStreamInterface_swigregister(PayloadStreamInterface)
class PayloadStream(PayloadStreamInterface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, h=-1):
        _message.PayloadStream_swiginit(self, _message.new_PayloadStream(h))
    __swig_destroy__ = _message.delete_PayloadStream

    def Get(self, buf, size):
        return _message.PayloadStream_Get(self, buf, size)

    def Put(self, buf, size):
        return _message.PayloadStream_Put(self, buf, size)

    def __nonzero__(self):
        return _message.PayloadStream___nonzero__(self)
    __bool__ = __nonzero__



    def Timeout(self, *args):
        return _message.PayloadStream_Timeout(self, *args)

    def Pos(self):
        return _message.PayloadStream_Pos(self)

    def Size(self):
        return _message.PayloadStream_Size(self)

    def Limit(self):
        return _message.PayloadStream_Limit(self)

# Register PayloadStream in _message:
_message.PayloadStream_swigregister(PayloadStream)
class Service(MCCInterface):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

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

    def AddSecHandler(self, *args):
        return _message.Service_AddSecHandler(self, *args)

    def getID(self):
        return _message.Service_getID(self)

    def __nonzero__(self):
        return _message.Service___nonzero__(self)
    __bool__ = __nonzero__



# Register Service in _message:
_message.Service_swigregister(Service)
ServicePluginKind = _message.ServicePluginKind
class ServicePluginArgument(loader.PluginArgument):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, config, context):
        _message.ServicePluginArgument_swiginit(self, _message.new_ServicePluginArgument(config, context))
    __swig_destroy__ = _message.delete_ServicePluginArgument

# Register ServicePluginArgument in _message:
_message.ServicePluginArgument_swigregister(ServicePluginArgument)