nordugrid-arc-python 4.0.0-1 / usr / share / pyshared / arc / message.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('_message', [dirname(__file__)])
        except ImportError:
            from arc import _message
            return _message
        if fp is not None:
            try:
                _mod = imp.load_module('_message', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _message = swig_import_helper()
    del swig_import_helper
else:
    from arc import _message
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__ = _message.delete_SwigPyIterator
    __del__ = lambda self : None;
    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, *args): return _message.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _message.SwigPyIterator_equal(self, *args)
    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, *args): return _message.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _message.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _message.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _message.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _message.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _message.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _message.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _message.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 = _message.new_StringPair(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_setmethods__["first"] = _message.StringPair_first_set
    __swig_getmethods__["first"] = _message.StringPair_first_get
    if _newclass:first = _swig_property(_message.StringPair_first_get, _message.StringPair_first_set)
    __swig_setmethods__["second"] = _message.StringPair_second_set
    __swig_getmethods__["second"] = _message.StringPair_second_get
    if _newclass:second = _swig_property(_message.StringPair_second_get, _message.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__ = _message.delete_StringPair
    __del__ = lambda self : None;
StringPair_swigregister = _message.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 _message.StringList_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _message.StringList___nonzero__(self)
    def __bool__(self): return _message.StringList___bool__(self)
    def __len__(self): return _message.StringList___len__(self)
    def pop(self): return _message.StringList_pop(self)
    def __getslice__(self, *args): return _message.StringList___getslice__(self, *args)
    def __setslice__(self, *args): return _message.StringList___setslice__(self, *args)
    def __delslice__(self, *args): return _message.StringList___delslice__(self, *args)
    def __delitem__(self, *args): return _message.StringList___delitem__(self, *args)
    def __getitem__(self, *args): return _message.StringList___getitem__(self, *args)
    def __setitem__(self, *args): return _message.StringList___setitem__(self, *args)
    def append(self, *args): return _message.StringList_append(self, *args)
    def empty(self): return _message.StringList_empty(self)
    def size(self): return _message.StringList_size(self)
    def clear(self): return _message.StringList_clear(self)
    def swap(self, *args): return _message.StringList_swap(self, *args)
    def get_allocator(self): return _message.StringList_get_allocator(self)
    def begin(self): return _message.StringList_begin(self)
    def end(self): return _message.StringList_end(self)
    def rbegin(self): return _message.StringList_rbegin(self)
    def rend(self): return _message.StringList_rend(self)
    def pop_back(self): return _message.StringList_pop_back(self)
    def erase(self, *args): return _message.StringList_erase(self, *args)
    def __init__(self, *args): 
        this = _message.new_StringList(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _message.StringList_push_back(self, *args)
    def front(self): return _message.StringList_front(self)
    def back(self): return _message.StringList_back(self)
    def assign(self, *args): return _message.StringList_assign(self, *args)
    def resize(self, *args): return _message.StringList_resize(self, *args)
    def insert(self, *args): return _message.StringList_insert(self, *args)
    def pop_front(self): return _message.StringList_pop_front(self)
    def push_front(self, *args): return _message.StringList_push_front(self, *args)
    def reverse(self): return _message.StringList_reverse(self)
    __swig_destroy__ = _message.delete_StringList
    __del__ = lambda self : None;
StringList_swigregister = _message.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 _message.StringSet_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _message.StringSet___nonzero__(self)
    def __bool__(self): return _message.StringSet___bool__(self)
    def __len__(self): return _message.StringSet___len__(self)
    def append(self, *args): return _message.StringSet_append(self, *args)
    def __contains__(self, *args): return _message.StringSet___contains__(self, *args)
    def __getitem__(self, *args): return _message.StringSet___getitem__(self, *args)
    def add(self, *args): return _message.StringSet_add(self, *args)
    def discard(self, *args): return _message.StringSet_discard(self, *args)
    def __init__(self, *args): 
        this = _message.new_StringSet(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _message.StringSet_empty(self)
    def size(self): return _message.StringSet_size(self)
    def clear(self): return _message.StringSet_clear(self)
    def swap(self, *args): return _message.StringSet_swap(self, *args)
    def count(self, *args): return _message.StringSet_count(self, *args)
    def begin(self): return _message.StringSet_begin(self)
    def end(self): return _message.StringSet_end(self)
    def rbegin(self): return _message.StringSet_rbegin(self)
    def rend(self): return _message.StringSet_rend(self)
    def erase(self, *args): return _message.StringSet_erase(self, *args)
    def find(self, *args): return _message.StringSet_find(self, *args)
    def lower_bound(self, *args): return _message.StringSet_lower_bound(self, *args)
    def upper_bound(self, *args): return _message.StringSet_upper_bound(self, *args)
    def equal_range(self, *args): return _message.StringSet_equal_range(self, *args)
    def insert(self, *args): return _message.StringSet_insert(self, *args)
    __swig_destroy__ = _message.delete_StringSet
    __del__ = lambda self : None;
StringSet_swigregister = _message.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 _message.StringVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _message.StringVector___nonzero__(self)
    def __bool__(self): return _message.StringVector___bool__(self)
    def __len__(self): return _message.StringVector___len__(self)
    def pop(self): return _message.StringVector_pop(self)
    def __getslice__(self, *args): return _message.StringVector___getslice__(self, *args)
    def __setslice__(self, *args): return _message.StringVector___setslice__(self, *args)
    def __delslice__(self, *args): return _message.StringVector___delslice__(self, *args)
    def __delitem__(self, *args): return _message.StringVector___delitem__(self, *args)
    def __getitem__(self, *args): return _message.StringVector___getitem__(self, *args)
    def __setitem__(self, *args): return _message.StringVector___setitem__(self, *args)
    def append(self, *args): return _message.StringVector_append(self, *args)
    def empty(self): return _message.StringVector_empty(self)
    def size(self): return _message.StringVector_size(self)
    def clear(self): return _message.StringVector_clear(self)
    def swap(self, *args): return _message.StringVector_swap(self, *args)
    def get_allocator(self): return _message.StringVector_get_allocator(self)
    def begin(self): return _message.StringVector_begin(self)
    def end(self): return _message.StringVector_end(self)
    def rbegin(self): return _message.StringVector_rbegin(self)
    def rend(self): return _message.StringVector_rend(self)
    def pop_back(self): return _message.StringVector_pop_back(self)
    def erase(self, *args): return _message.StringVector_erase(self, *args)
    def __init__(self, *args): 
        this = _message.new_StringVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _message.StringVector_push_back(self, *args)
    def front(self): return _message.StringVector_front(self)
    def back(self): return _message.StringVector_back(self)
    def assign(self, *args): return _message.StringVector_assign(self, *args)
    def resize(self, *args): return _message.StringVector_resize(self, *args)
    def insert(self, *args): return _message.StringVector_insert(self, *args)
    def reserve(self, *args): return _message.StringVector_reserve(self, *args)
    def capacity(self): return _message.StringVector_capacity(self)
    __swig_destroy__ = _message.delete_StringVector
    __del__ = lambda self : None;
StringVector_swigregister = _message.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 _message.StringStringMap_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _message.StringStringMap___nonzero__(self)
    def __bool__(self): return _message.StringStringMap___bool__(self)
    def __len__(self): return _message.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 _message.StringStringMap___getitem__(self, *args)
    def __delitem__(self, *args): return _message.StringStringMap___delitem__(self, *args)
    def has_key(self, *args): return _message.StringStringMap_has_key(self, *args)
    def keys(self): return _message.StringStringMap_keys(self)
    def values(self): return _message.StringStringMap_values(self)
    def items(self): return _message.StringStringMap_items(self)
    def __contains__(self, *args): return _message.StringStringMap___contains__(self, *args)
    def key_iterator(self): return _message.StringStringMap_key_iterator(self)
    def value_iterator(self): return _message.StringStringMap_value_iterator(self)
    def __setitem__(self, *args): return _message.StringStringMap___setitem__(self, *args)
    def asdict(self): return _message.StringStringMap_asdict(self)
    def __init__(self, *args): 
        this = _message.new_StringStringMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _message.StringStringMap_empty(self)
    def size(self): return _message.StringStringMap_size(self)
    def clear(self): return _message.StringStringMap_clear(self)
    def swap(self, *args): return _message.StringStringMap_swap(self, *args)
    def get_allocator(self): return _message.StringStringMap_get_allocator(self)
    def begin(self): return _message.StringStringMap_begin(self)
    def end(self): return _message.StringStringMap_end(self)
    def rbegin(self): return _message.StringStringMap_rbegin(self)
    def rend(self): return _message.StringStringMap_rend(self)
    def count(self, *args): return _message.StringStringMap_count(self, *args)
    def erase(self, *args): return _message.StringStringMap_erase(self, *args)
    def find(self, *args): return _message.StringStringMap_find(self, *args)
    def lower_bound(self, *args): return _message.StringStringMap_lower_bound(self, *args)
    def upper_bound(self, *args): return _message.StringStringMap_upper_bound(self, *args)
    __swig_destroy__ = _message.delete_StringStringMap
    __del__ = lambda self : None;
StringStringMap_swigregister = _message.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 _message.StringDoubleMap_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _message.StringDoubleMap___nonzero__(self)
    def __bool__(self): return _message.StringDoubleMap___bool__(self)
    def __len__(self): return _message.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 _message.StringDoubleMap___getitem__(self, *args)
    def __delitem__(self, *args): return _message.StringDoubleMap___delitem__(self, *args)
    def has_key(self, *args): return _message.StringDoubleMap_has_key(self, *args)
    def keys(self): return _message.StringDoubleMap_keys(self)
    def values(self): return _message.StringDoubleMap_values(self)
    def items(self): return _message.StringDoubleMap_items(self)
    def __contains__(self, *args): return _message.StringDoubleMap___contains__(self, *args)
    def key_iterator(self): return _message.StringDoubleMap_key_iterator(self)
    def value_iterator(self): return _message.StringDoubleMap_value_iterator(self)
    def __setitem__(self, *args): return _message.StringDoubleMap___setitem__(self, *args)
    def asdict(self): return _message.StringDoubleMap_asdict(self)
    def __init__(self, *args): 
        this = _message.new_StringDoubleMap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self): return _message.StringDoubleMap_empty(self)
    def size(self): return _message.StringDoubleMap_size(self)
    def clear(self): return _message.StringDoubleMap_clear(self)
    def swap(self, *args): return _message.StringDoubleMap_swap(self, *args)
    def get_allocator(self): return _message.StringDoubleMap_get_allocator(self)
    def begin(self): return _message.StringDoubleMap_begin(self)
    def end(self): return _message.StringDoubleMap_end(self)
    def rbegin(self): return _message.StringDoubleMap_rbegin(self)
    def rend(self): return _message.StringDoubleMap_rend(self)
    def count(self, *args): return _message.StringDoubleMap_count(self, *args)
    def erase(self, *args): return _message.StringDoubleMap_erase(self, *args)
    def find(self, *args): return _message.StringDoubleMap_find(self, *args)
    def lower_bound(self, *args): return _message.StringDoubleMap_lower_bound(self, *args)
    def upper_bound(self, *args): return _message.StringDoubleMap_upper_bound(self, *args)
    __swig_destroy__ = _message.delete_StringDoubleMap
    __del__ = lambda self : None;
StringDoubleMap_swigregister = _message.StringDoubleMap_swigregister
StringDoubleMap_swigregister(StringDoubleMap)

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(*args):
  return _message.string(*args)
string = _message.string
class MCC_Status(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCC_Status, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MCC_Status, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_MCC_Status(*args)
        try: self.this.append(this)
        except: self.this = this
    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
    __del__ = lambda self : None;
MCC_Status_swigregister = _message.MCC_Status_swigregister
MCC_Status_swigregister(MCC_Status)

class AttributeIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, AttributeIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, AttributeIterator, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_AttributeIterator()
        try: self.this.append(this)
        except: self.this = this
    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
    __del__ = lambda self : None;
AttributeIterator_swigregister = _message.AttributeIterator_swigregister
AttributeIterator_swigregister(AttributeIterator)

class MessageAttributes(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MessageAttributes, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MessageAttributes, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MessageAttributes()
        try: self.this.append(this)
        except: self.this = this
    def set(self, *args): return _message.MessageAttributes_set(self, *args)
    def add(self, *args): return _message.MessageAttributes_add(self, *args)
    def removeAll(self, *args): return _message.MessageAttributes_removeAll(self, *args)
    def remove(self, *args): return _message.MessageAttributes_remove(self, *args)
    def count(self, *args): return _message.MessageAttributes_count(self, *args)
    def get(self, *args): return _message.MessageAttributes_get(self, *args)
    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
    __del__ = lambda self : None;
MessageAttributes_swigregister = _message.MessageAttributes_swigregister
MessageAttributes_swigregister(MessageAttributes)

class SecAttrFormat(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SecAttrFormat, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SecAttrFormat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_SecAttrFormat(*args)
        try: self.this.append(this)
        except: self.this = this
    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
    __del__ = lambda self : None;
SecAttrFormat_swigregister = _message.SecAttrFormat_swigregister
SecAttrFormat_swigregister(SecAttrFormat)

class SecAttr(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SecAttr, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SecAttr, name)
    __repr__ = _swig_repr
    __swig_setmethods__["UNDEFINED"] = _message.SecAttr_UNDEFINED_set
    __swig_getmethods__["UNDEFINED"] = _message.SecAttr_UNDEFINED_get
    if _newclass:UNDEFINED = _swig_property(_message.SecAttr_UNDEFINED_get, _message.SecAttr_UNDEFINED_set)
    __swig_setmethods__["ARCAuth"] = _message.SecAttr_ARCAuth_set
    __swig_getmethods__["ARCAuth"] = _message.SecAttr_ARCAuth_get
    if _newclass:ARCAuth = _swig_property(_message.SecAttr_ARCAuth_get, _message.SecAttr_ARCAuth_set)
    __swig_setmethods__["XACML"] = _message.SecAttr_XACML_set
    __swig_getmethods__["XACML"] = _message.SecAttr_XACML_get
    if _newclass:XACML = _swig_property(_message.SecAttr_XACML_get, _message.SecAttr_XACML_set)
    __swig_setmethods__["SAML"] = _message.SecAttr_SAML_set
    __swig_getmethods__["SAML"] = _message.SecAttr_SAML_get
    if _newclass:SAML = _swig_property(_message.SecAttr_SAML_get, _message.SecAttr_SAML_set)
    __swig_setmethods__["GACL"] = _message.SecAttr_GACL_set
    __swig_getmethods__["GACL"] = _message.SecAttr_GACL_get
    if _newclass:GACL = _swig_property(_message.SecAttr_GACL_get, _message.SecAttr_GACL_set)
    def __init__(self): 
        this = _message.new_SecAttr()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_SecAttr
    __del__ = lambda self : None;
    def __eq__(self, *args): return _message.SecAttr___eq__(self, *args)
    def __ne__(self, *args): return _message.SecAttr___ne__(self, *args)
    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, *args): return _message.SecAttr_get(self, *args)
    def getAll(self, *args): return _message.SecAttr_getAll(self, *args)
SecAttr_swigregister = _message.SecAttr_swigregister
SecAttr_swigregister(SecAttr)
cvar = _message.cvar

class MultiSecAttr(SecAttr):
    __swig_setmethods__ = {}
    for _s in [SecAttr]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MultiSecAttr, name, value)
    __swig_getmethods__ = {}
    for _s in [SecAttr]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MultiSecAttr, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MultiSecAttr()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MultiSecAttr
    __del__ = lambda self : None;
    def __nonzero__(self):
        return _message.MultiSecAttr___nonzero__(self)
    __bool__ = __nonzero__


    def Export(self, *args): return _message.MultiSecAttr_Export(self, *args)
    def Import(self, *args): return _message.MultiSecAttr_Import(self, *args)
MultiSecAttr_swigregister = _message.MultiSecAttr_swigregister
MultiSecAttr_swigregister(MultiSecAttr)

class MessageAuth(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MessageAuth, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MessageAuth, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MessageAuth()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MessageAuth
    __del__ = lambda self : None;
    def set(self, *args): return _message.MessageAuth_set(self, *args)
    def remove(self, *args): return _message.MessageAuth_remove(self, *args)
    def get(self, *args): return _message.MessageAuth_get(self, *args)
    def Export(self, *args):
        x = XMLNode("<dummy/>")
        args = args[:-1] + (args[-1].fget(), x)



        val = _message.MessageAuth_Export(self, *args)
        return x


        return val

    def Filter(self, *args): return _message.MessageAuth_Filter(self, *args)
MessageAuth_swigregister = _message.MessageAuth_swigregister
MessageAuth_swigregister(MessageAuth)

class MessagePayload(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MessagePayload, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MessagePayload, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MessagePayload()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MessagePayload
    __del__ = lambda self : None;
    def Failure(self): return _message.MessagePayload_Failure(self)
MessagePayload_swigregister = _message.MessagePayload_swigregister
MessagePayload_swigregister(MessagePayload)

class MessageContextElement(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MessageContextElement, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MessageContextElement, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MessageContextElement()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MessageContextElement
    __del__ = lambda self : None;
MessageContextElement_swigregister = _message.MessageContextElement_swigregister
MessageContextElement_swigregister(MessageContextElement)

class MessageContext(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MessageContext, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MessageContext, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MessageContext()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MessageContext
    __del__ = lambda self : None;
    def Add(self, *args): return _message.MessageContext_Add(self, *args)
MessageContext_swigregister = _message.MessageContext_swigregister
MessageContext_swigregister(MessageContext)

class MessageAuthContext(MessageAuth):
    __swig_setmethods__ = {}
    for _s in [MessageAuth]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MessageAuthContext, name, value)
    __swig_getmethods__ = {}
    for _s in [MessageAuth]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MessageAuthContext, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MessageAuthContext()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MessageAuthContext
    __del__ = lambda self : None;
MessageAuthContext_swigregister = _message.MessageAuthContext_swigregister
MessageAuthContext_swigregister(MessageAuthContext)

class Message(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Message, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Message, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_Message(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_Message
    __del__ = lambda self : None;
    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)
Message_swigregister = _message.Message_swigregister
Message_swigregister(Message)

class MCCInterface(loader.Plugin):
    __swig_setmethods__ = {}
    for _s in [loader.Plugin]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCCInterface, name, value)
    __swig_getmethods__ = {}
    for _s in [loader.Plugin]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MCCInterface, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def process(self, *args): return _message.MCCInterface_process(self, *args)
    __swig_destroy__ = _message.delete_MCCInterface
    __del__ = lambda self : None;
MCCInterface_swigregister = _message.MCCInterface_swigregister
MCCInterface_swigregister(MCCInterface)

class MCC(MCCInterface):
    __swig_setmethods__ = {}
    for _s in [MCCInterface]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCC, name, value)
    __swig_getmethods__ = {}
    for _s in [MCCInterface]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MCC, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_MCC(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MCC
    __del__ = lambda self : None;
    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, *args): return _message.MCC_process(self, *args)
MCC_swigregister = _message.MCC_swigregister
MCC_swigregister(MCC)

class MCCConfig(common.BaseConfig):
    __swig_setmethods__ = {}
    for _s in [common.BaseConfig]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCCConfig, name, value)
    __swig_getmethods__ = {}
    for _s in [common.BaseConfig]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MCCConfig, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_MCCConfig()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MCCConfig
    __del__ = lambda self : None;
    def MakeConfig(self, *args): return _message.MCCConfig_MakeConfig(self, *args)
MCCConfig_swigregister = _message.MCCConfig_swigregister
MCCConfig_swigregister(MCCConfig)

MCCPluginKind = _message.MCCPluginKind
class MCCPluginArgument(loader.PluginArgument):
    __swig_setmethods__ = {}
    for _s in [loader.PluginArgument]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MCCPluginArgument, name, value)
    __swig_getmethods__ = {}
    for _s in [loader.PluginArgument]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MCCPluginArgument, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_MCCPluginArgument(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_MCCPluginArgument
    __del__ = lambda self : None;
MCCPluginArgument_swigregister = _message.MCCPluginArgument_swigregister
MCCPluginArgument_swigregister(MCCPluginArgument)

class PayloadRawInterface(MessagePayload):
    __swig_setmethods__ = {}
    for _s in [MessagePayload]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadRawInterface, name, value)
    __swig_getmethods__ = {}
    for _s in [MessagePayload]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadRawInterface, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _message.delete_PayloadRawInterface
    __del__ = lambda self : None;
    def Content(self, *args): return _message.PayloadRawInterface_Content(self, *args)
    def Size(self): return _message.PayloadRawInterface_Size(self)
    def Insert(self, *args): return _message.PayloadRawInterface_Insert(self, *args)
    def Buffer(self, *args): return _message.PayloadRawInterface_Buffer(self, *args)
    def BufferSize(self, *args): return _message.PayloadRawInterface_BufferSize(self, *args)
    def BufferPos(self, *args): return _message.PayloadRawInterface_BufferPos(self, *args)
    def Truncate(self, *args): return _message.PayloadRawInterface_Truncate(self, *args)
PayloadRawInterface_swigregister = _message.PayloadRawInterface_swigregister
PayloadRawInterface_swigregister(PayloadRawInterface)

class PayloadRawBuf(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadRawBuf, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadRawBuf, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _message.PayloadRawBuf_data_set
    __swig_getmethods__["data"] = _message.PayloadRawBuf_data_get
    if _newclass:data = _swig_property(_message.PayloadRawBuf_data_get, _message.PayloadRawBuf_data_set)
    __swig_setmethods__["size"] = _message.PayloadRawBuf_size_set
    __swig_getmethods__["size"] = _message.PayloadRawBuf_size_get
    if _newclass:size = _swig_property(_message.PayloadRawBuf_size_get, _message.PayloadRawBuf_size_set)
    __swig_setmethods__["length"] = _message.PayloadRawBuf_length_set
    __swig_getmethods__["length"] = _message.PayloadRawBuf_length_get
    if _newclass:length = _swig_property(_message.PayloadRawBuf_length_get, _message.PayloadRawBuf_length_set)
    __swig_setmethods__["allocated"] = _message.PayloadRawBuf_allocated_set
    __swig_getmethods__["allocated"] = _message.PayloadRawBuf_allocated_get
    if _newclass:allocated = _swig_property(_message.PayloadRawBuf_allocated_get, _message.PayloadRawBuf_allocated_set)
    def __init__(self): 
        this = _message.new_PayloadRawBuf()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_PayloadRawBuf
    __del__ = lambda self : None;
PayloadRawBuf_swigregister = _message.PayloadRawBuf_swigregister
PayloadRawBuf_swigregister(PayloadRawBuf)

class PayloadRaw(PayloadRawInterface):
    __swig_setmethods__ = {}
    for _s in [PayloadRawInterface]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadRaw, name, value)
    __swig_getmethods__ = {}
    for _s in [PayloadRawInterface]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadRaw, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _message.new_PayloadRaw()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_PayloadRaw
    __del__ = lambda self : None;
    def Content(self, *args): return _message.PayloadRaw_Content(self, *args)
    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, *args): return _message.PayloadRaw_Truncate(self, *args)
PayloadRaw_swigregister = _message.PayloadRaw_swigregister
PayloadRaw_swigregister(PayloadRaw)


def ContentFromPayload(*args):
  return _message.ContentFromPayload(*args)
ContentFromPayload = _message.ContentFromPayload
class SOAPFault(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SOAPFault, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SOAPFault, name)
    __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): 
        this = _message.new_SOAPFault(*args)
        try: self.this.append(this)
        except: self.this = this
    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)
    __swig_getmethods__["MakeSOAPFault"] = lambda x: _message.SOAPFault_MakeSOAPFault
    if _newclass:MakeSOAPFault = staticmethod(_message.SOAPFault_MakeSOAPFault)
    __swig_destroy__ = _message.delete_SOAPFault
    __del__ = lambda self : None;
SOAPFault_swigregister = _message.SOAPFault_swigregister
SOAPFault_swigregister(SOAPFault)

def SOAPFault_MakeSOAPFault(*args):
  return _message.SOAPFault_MakeSOAPFault(*args)
SOAPFault_MakeSOAPFault = _message.SOAPFault_MakeSOAPFault

class SOAPEnvelope(common.XMLNode):
    __swig_setmethods__ = {}
    for _s in [common.XMLNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SOAPEnvelope, name, value)
    __swig_getmethods__ = {}
    for _s in [common.XMLNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SOAPEnvelope, name)
    __repr__ = _swig_repr
    Version_1_1 = _message.SOAPEnvelope_Version_1_1
    Version_1_2 = _message.SOAPEnvelope_Version_1_2
    def __init__(self, *args): 
        this = _message.new_SOAPEnvelope(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_SOAPEnvelope
    __del__ = lambda self : None;
    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)
SOAPEnvelope_swigregister = _message.SOAPEnvelope_swigregister
SOAPEnvelope_swigregister(SOAPEnvelope)

class SOAPMessage(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SOAPMessage, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SOAPMessage, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_SOAPMessage(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_SOAPMessage
    __del__ = lambda self : None;
    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)
SOAPMessage_swigregister = _message.SOAPMessage_swigregister
SOAPMessage_swigregister(SOAPMessage)

class PayloadSOAP(SOAPEnvelope,MessagePayload):
    __swig_setmethods__ = {}
    for _s in [SOAPEnvelope,MessagePayload]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadSOAP, name, value)
    __swig_getmethods__ = {}
    for _s in [SOAPEnvelope,MessagePayload]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadSOAP, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_PayloadSOAP(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_PayloadSOAP
    __del__ = lambda self : None;
PayloadSOAP_swigregister = _message.PayloadSOAP_swigregister
PayloadSOAP_swigregister(PayloadSOAP)

class PayloadStreamInterface(MessagePayload):
    __swig_setmethods__ = {}
    for _s in [MessagePayload]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadStreamInterface, name, value)
    __swig_getmethods__ = {}
    for _s in [MessagePayload]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadStreamInterface, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _message.delete_PayloadStreamInterface
    __del__ = lambda self : None;
    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)
PayloadStreamInterface_swigregister = _message.PayloadStreamInterface_swigregister
PayloadStreamInterface_swigregister(PayloadStreamInterface)

class PayloadStream(PayloadStreamInterface):
    __swig_setmethods__ = {}
    for _s in [PayloadStreamInterface]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PayloadStream, name, value)
    __swig_getmethods__ = {}
    for _s in [PayloadStreamInterface]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PayloadStream, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_PayloadStream(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_PayloadStream
    __del__ = lambda self : None;
    def Get(self, *args): return _message.PayloadStream_Get(self, *args)
    def Put(self, *args): return _message.PayloadStream_Put(self, *args)
    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)
PayloadStream_swigregister = _message.PayloadStream_swigregister
PayloadStream_swigregister(PayloadStream)

class Service(MCCInterface):
    __swig_setmethods__ = {}
    for _s in [MCCInterface]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Service, name, value)
    __swig_getmethods__ = {}
    for _s in [MCCInterface]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Service, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _message.delete_Service
    __del__ = lambda self : None;
    def AddSecHandler(self, *args): return _message.Service_AddSecHandler(self, *args)
    def RegistrationCollector(self, *args): return _message.Service_RegistrationCollector(self, *args)
    def getID(self): return _message.Service_getID(self)
    def __nonzero__(self):
        return _message.Service___nonzero__(self)
    __bool__ = __nonzero__


Service_swigregister = _message.Service_swigregister
Service_swigregister(Service)

ServicePluginKind = _message.ServicePluginKind
class ServicePluginArgument(loader.PluginArgument):
    __swig_setmethods__ = {}
    for _s in [loader.PluginArgument]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ServicePluginArgument, name, value)
    __swig_getmethods__ = {}
    for _s in [loader.PluginArgument]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ServicePluginArgument, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _message.new_ServicePluginArgument(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _message.delete_ServicePluginArgument
    __del__ = lambda self : None;
ServicePluginArgument_swigregister = _message.ServicePluginArgument_swigregister
ServicePluginArgument_swigregister(ServicePluginArgument)

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