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

"""
All is needed to create and execute a calculation schema.
"""

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

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

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

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

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


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class pilot_PySwigIterator(_object):
    """Proxy of C++ swig::pilot_PySwigIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pilot_PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pilot_PySwigIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_pilot_PySwigIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _pilot.pilot_PySwigIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, size_t n = 1) -> pilot_PySwigIterator
        incr(self) -> pilot_PySwigIterator
        """
        return _pilot.pilot_PySwigIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, size_t n = 1) -> pilot_PySwigIterator
        decr(self) -> pilot_PySwigIterator
        """
        return _pilot.pilot_PySwigIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, pilot_PySwigIterator x) -> ptrdiff_t"""
        return _pilot.pilot_PySwigIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, pilot_PySwigIterator x) -> bool"""
        return _pilot.pilot_PySwigIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> pilot_PySwigIterator"""
        return _pilot.pilot_PySwigIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _pilot.pilot_PySwigIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _pilot.pilot_PySwigIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _pilot.pilot_PySwigIterator_previous(self)

    def advance(self, *args):
        """advance(self, ptrdiff_t n) -> pilot_PySwigIterator"""
        return _pilot.pilot_PySwigIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, pilot_PySwigIterator x) -> bool"""
        return _pilot.pilot_PySwigIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, pilot_PySwigIterator x) -> bool"""
        return _pilot.pilot_PySwigIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, ptrdiff_t n) -> pilot_PySwigIterator"""
        return _pilot.pilot_PySwigIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, ptrdiff_t n) -> pilot_PySwigIterator"""
        return _pilot.pilot_PySwigIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, ptrdiff_t n) -> pilot_PySwigIterator"""
        return _pilot.pilot_PySwigIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> pilot_PySwigIterator
        __sub__(self, pilot_PySwigIterator x) -> ptrdiff_t
        """
        return _pilot.pilot_PySwigIterator___sub__(self, *args)

    def __iter__(self): return self
pilot_PySwigIterator_swigregister = _pilot.pilot_PySwigIterator_swigregister
pilot_PySwigIterator_swigregister(pilot_PySwigIterator)

class TCmap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::TypeCode)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, TCmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, TCmap, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """__setitem__(self, string name, TypeCode c)"""
        return _pilot.TCmap___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, string name) -> TypeCode"""
        return _pilot.TCmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, string name)"""
        return _pilot.TCmap___delitem__(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.TCmap_keys(self)

    def __init__(self): 
        """__init__(self) -> TCmap"""
        this = _pilot.new_TCmap()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_TCmap
    __del__ = lambda self : None;
TCmap_swigregister = _pilot.TCmap_swigregister
TCmap_swigregister(TCmap)

from UserDict import DictMixin
class TCmap(TCmap,DictMixin):pass
TCmap_swigregister(TCmap)

class NODEmap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::Node)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NODEmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NODEmap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.NODEmap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.NODEmap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.NODEmap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.NODEmap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _pilot.NODEmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _pilot.NODEmap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _pilot.NODEmap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.NODEmap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _pilot.NODEmap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _pilot.NODEmap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _pilot.NODEmap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.NODEmap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.NODEmap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _pilot.NODEmap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> NODEmap
        __init__(self) -> NODEmap
        __init__(self, NODEmap arg0) -> NODEmap
        """
        this = _pilot.new_NODEmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _pilot.NODEmap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.NODEmap_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.NODEmap_clear(self)

    def swap(self, *args):
        """swap(self, NODEmap v)"""
        return _pilot.NODEmap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.NODEmap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.NODEmap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.NODEmap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.NODEmap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.NODEmap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _pilot.NODEmap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _pilot.NODEmap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _pilot.NODEmap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _pilot.NODEmap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _pilot.NODEmap_upper_bound(self, *args)

    __swig_destroy__ = _pilot.delete_NODEmap
    __del__ = lambda self : None;
NODEmap_swigregister = _pilot.NODEmap_swigregister
NODEmap_swigregister(NODEmap)

class INODEmap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::InlineNode)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, INODEmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, INODEmap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.INODEmap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.INODEmap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.INODEmap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.INODEmap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _pilot.INODEmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _pilot.INODEmap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _pilot.INODEmap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.INODEmap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _pilot.INODEmap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _pilot.INODEmap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _pilot.INODEmap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.INODEmap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.INODEmap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _pilot.INODEmap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> INODEmap
        __init__(self) -> INODEmap
        __init__(self, INODEmap arg0) -> INODEmap
        """
        this = _pilot.new_INODEmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _pilot.INODEmap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.INODEmap_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.INODEmap_clear(self)

    def swap(self, *args):
        """swap(self, INODEmap v)"""
        return _pilot.INODEmap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.INODEmap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.INODEmap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.INODEmap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.INODEmap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.INODEmap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _pilot.INODEmap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _pilot.INODEmap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _pilot.INODEmap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _pilot.INODEmap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _pilot.INODEmap_upper_bound(self, *args)

    __swig_destroy__ = _pilot.delete_INODEmap
    __del__ = lambda self : None;
INODEmap_swigregister = _pilot.INODEmap_swigregister
INODEmap_swigregister(INODEmap)

class SNODEmap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::ServiceNode)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SNODEmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SNODEmap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.SNODEmap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.SNODEmap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.SNODEmap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.SNODEmap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _pilot.SNODEmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _pilot.SNODEmap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _pilot.SNODEmap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.SNODEmap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _pilot.SNODEmap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _pilot.SNODEmap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _pilot.SNODEmap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.SNODEmap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.SNODEmap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _pilot.SNODEmap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> SNODEmap
        __init__(self) -> SNODEmap
        __init__(self, SNODEmap arg0) -> SNODEmap
        """
        this = _pilot.new_SNODEmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _pilot.SNODEmap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.SNODEmap_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.SNODEmap_clear(self)

    def swap(self, *args):
        """swap(self, SNODEmap v)"""
        return _pilot.SNODEmap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.SNODEmap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.SNODEmap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.SNODEmap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.SNODEmap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.SNODEmap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _pilot.SNODEmap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _pilot.SNODEmap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _pilot.SNODEmap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _pilot.SNODEmap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _pilot.SNODEmap_upper_bound(self, *args)

    __swig_destroy__ = _pilot.delete_SNODEmap
    __del__ = lambda self : None;
SNODEmap_swigregister = _pilot.SNODEmap_swigregister
SNODEmap_swigregister(SNODEmap)

class CONTAINmap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::Container)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CONTAINmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CONTAINmap, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """__setitem__(self, string name, Container c)"""
        return _pilot.CONTAINmap___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, string name) -> Container"""
        return _pilot.CONTAINmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, string name)"""
        return _pilot.CONTAINmap___delitem__(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.CONTAINmap_keys(self)

    def __init__(self): 
        """__init__(self) -> CONTAINmap"""
        this = _pilot.new_CONTAINmap()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_CONTAINmap
    __del__ = lambda self : None;
CONTAINmap_swigregister = _pilot.CONTAINmap_swigregister
CONTAINmap_swigregister(CONTAINmap)

from UserDict import DictMixin
class CONTAINmap(CONTAINmap,DictMixin):pass
CONTAINmap_swigregister(CONTAINmap)

class strvec(_object):
    """Proxy of C++ std::vector<(std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, strvec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, strvec, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.strvec_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.strvec___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.strvec___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.strvec___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _pilot.strvec_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> strvec"""
        return _pilot.strvec___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, strvec v)"""
        return _pilot.strvec___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _pilot.strvec___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _pilot.strvec___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> strvec
        __getitem__(self, difference_type i) -> value_type
        """
        return _pilot.strvec___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, strvec v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _pilot.strvec___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _pilot.strvec_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _pilot.strvec_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.strvec_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.strvec_clear(self)

    def swap(self, *args):
        """swap(self, strvec v)"""
        return _pilot.strvec_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.strvec_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.strvec_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.strvec_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.strvec_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.strvec_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _pilot.strvec_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _pilot.strvec_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> strvec
        __init__(self, strvec arg0) -> strvec
        __init__(self, size_type size) -> strvec
        __init__(self, size_type size, value_type value) -> strvec
        """
        this = _pilot.new_strvec(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _pilot.strvec_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _pilot.strvec_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _pilot.strvec_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _pilot.strvec_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _pilot.strvec_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _pilot.strvec_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _pilot.strvec_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _pilot.strvec_capacity(self)

    __swig_destroy__ = _pilot.delete_strvec
    __del__ = lambda self : None;
strvec_swigregister = _pilot.strvec_swigregister
strvec_swigregister(strvec)

class linksvec(_object):
    """Proxy of C++ std::vector<(std::pair<(p.YACS::ENGINE::OutPort,p.YACS::ENGINE::InPort)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, linksvec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, linksvec, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.linksvec_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.linksvec___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.linksvec___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.linksvec___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _pilot.linksvec_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> linksvec"""
        return _pilot.linksvec___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, linksvec v)"""
        return _pilot.linksvec___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _pilot.linksvec___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _pilot.linksvec___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> linksvec
        __getitem__(self, difference_type i) -> value_type
        """
        return _pilot.linksvec___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, linksvec v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _pilot.linksvec___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _pilot.linksvec_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _pilot.linksvec_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.linksvec_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.linksvec_clear(self)

    def swap(self, *args):
        """swap(self, linksvec v)"""
        return _pilot.linksvec_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.linksvec_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.linksvec_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.linksvec_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.linksvec_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.linksvec_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _pilot.linksvec_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _pilot.linksvec_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> linksvec
        __init__(self, linksvec arg0) -> linksvec
        __init__(self, size_type size) -> linksvec
        __init__(self, size_type size, value_type value) -> linksvec
        """
        this = _pilot.new_linksvec(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _pilot.linksvec_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _pilot.linksvec_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _pilot.linksvec_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _pilot.linksvec_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _pilot.linksvec_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _pilot.linksvec_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _pilot.linksvec_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _pilot.linksvec_capacity(self)

    __swig_destroy__ = _pilot.delete_linksvec
    __del__ = lambda self : None;
linksvec_swigregister = _pilot.linksvec_swigregister
linksvec_swigregister(linksvec)

class linkvec(_object):
    """Proxy of C++ std::vector<(std::pair<(p.YACS::ENGINE::InPort,p.YACS::ENGINE::OutPort)>)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, linkvec, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, linkvec, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.linkvec_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.linkvec___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.linkvec___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.linkvec___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _pilot.linkvec_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> linkvec"""
        return _pilot.linkvec___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, linkvec v)"""
        return _pilot.linkvec___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _pilot.linkvec___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _pilot.linkvec___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> linkvec
        __getitem__(self, difference_type i) -> value_type
        """
        return _pilot.linkvec___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, linkvec v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _pilot.linkvec___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _pilot.linkvec_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _pilot.linkvec_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.linkvec_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.linkvec_clear(self)

    def swap(self, *args):
        """swap(self, linkvec v)"""
        return _pilot.linkvec_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.linkvec_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.linkvec_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.linkvec_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.linkvec_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.linkvec_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _pilot.linkvec_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _pilot.linkvec_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> linkvec
        __init__(self, linkvec arg0) -> linkvec
        __init__(self, size_type size) -> linkvec
        __init__(self, size_type size, value_type value) -> linkvec
        """
        this = _pilot.new_linkvec(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _pilot.linkvec_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _pilot.linkvec_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _pilot.linkvec_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _pilot.linkvec_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _pilot.linkvec_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _pilot.linkvec_insert(self, *args)

    def reserve(self, *args):
        """reserve(self, size_type n)"""
        return _pilot.linkvec_reserve(self, *args)

    def capacity(self):
        """capacity(self) -> size_type"""
        return _pilot.linkvec_capacity(self)

    __swig_destroy__ = _pilot.delete_linkvec
    __del__ = lambda self : None;
linkvec_swigregister = _pilot.linkvec_swigregister
linkvec_swigregister(linkvec)

class instreamlist(_object):
    """Proxy of C++ std::list<(p.YACS::ENGINE::InputDataStreamPort)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, instreamlist, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, instreamlist, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.instreamlist_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.instreamlist___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.instreamlist___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.instreamlist___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _pilot.instreamlist_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> instreamlist"""
        return _pilot.instreamlist___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, instreamlist v)"""
        return _pilot.instreamlist___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _pilot.instreamlist___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _pilot.instreamlist___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> instreamlist
        __getitem__(self, difference_type i) -> value_type
        """
        return _pilot.instreamlist___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, instreamlist v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _pilot.instreamlist___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _pilot.instreamlist_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _pilot.instreamlist_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.instreamlist_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.instreamlist_clear(self)

    def swap(self, *args):
        """swap(self, instreamlist v)"""
        return _pilot.instreamlist_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.instreamlist_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.instreamlist_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.instreamlist_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.instreamlist_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.instreamlist_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _pilot.instreamlist_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _pilot.instreamlist_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> instreamlist
        __init__(self, instreamlist arg0) -> instreamlist
        __init__(self, size_type size) -> instreamlist
        __init__(self, size_type size, value_type value) -> instreamlist
        """
        this = _pilot.new_instreamlist(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _pilot.instreamlist_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _pilot.instreamlist_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _pilot.instreamlist_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _pilot.instreamlist_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _pilot.instreamlist_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _pilot.instreamlist_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _pilot.instreamlist_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _pilot.instreamlist_push_front(self, *args)

    def remove(self, *args):
        """remove(self, value_type x)"""
        return _pilot.instreamlist_remove(self, *args)

    def unique(self):
        """unique(self)"""
        return _pilot.instreamlist_unique(self)

    def reverse(self):
        """reverse(self)"""
        return _pilot.instreamlist_reverse(self)

    def sort(self):
        """sort(self)"""
        return _pilot.instreamlist_sort(self)

    def merge(self, *args):
        """merge(self, instreamlist x)"""
        return _pilot.instreamlist_merge(self, *args)

    __swig_destroy__ = _pilot.delete_instreamlist
    __del__ = lambda self : None;
instreamlist_swigregister = _pilot.instreamlist_swigregister
instreamlist_swigregister(instreamlist)

class outstreamlist(_object):
    """Proxy of C++ std::list<(p.YACS::ENGINE::OutputDataStreamPort)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, outstreamlist, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, outstreamlist, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.outstreamlist_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.outstreamlist___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.outstreamlist___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.outstreamlist___len__(self)

    def pop(self):
        """pop(self) -> value_type"""
        return _pilot.outstreamlist_pop(self)

    def __getslice__(self, *args):
        """__getslice__(self, difference_type i, difference_type j) -> outstreamlist"""
        return _pilot.outstreamlist___getslice__(self, *args)

    def __setslice__(self, *args):
        """__setslice__(self, difference_type i, difference_type j, outstreamlist v)"""
        return _pilot.outstreamlist___setslice__(self, *args)

    def __delslice__(self, *args):
        """__delslice__(self, difference_type i, difference_type j)"""
        return _pilot.outstreamlist___delslice__(self, *args)

    def __delitem__(self, *args):
        """
        __delitem__(self, difference_type i)
        __delitem__(self, PySliceObject slice)
        """
        return _pilot.outstreamlist___delitem__(self, *args)

    def __getitem__(self, *args):
        """
        __getitem__(self, PySliceObject slice) -> outstreamlist
        __getitem__(self, difference_type i) -> value_type
        """
        return _pilot.outstreamlist___getitem__(self, *args)

    def __setitem__(self, *args):
        """
        __setitem__(self, PySliceObject slice, outstreamlist v)
        __setitem__(self, difference_type i, value_type x)
        """
        return _pilot.outstreamlist___setitem__(self, *args)

    def append(self, *args):
        """append(self, value_type x)"""
        return _pilot.outstreamlist_append(self, *args)

    def empty(self):
        """empty(self) -> bool"""
        return _pilot.outstreamlist_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.outstreamlist_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.outstreamlist_clear(self)

    def swap(self, *args):
        """swap(self, outstreamlist v)"""
        return _pilot.outstreamlist_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.outstreamlist_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.outstreamlist_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.outstreamlist_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.outstreamlist_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.outstreamlist_rend(self)

    def pop_back(self):
        """pop_back(self)"""
        return _pilot.outstreamlist_pop_back(self)

    def erase(self, *args):
        """
        erase(self, iterator pos) -> iterator
        erase(self, iterator first, iterator last) -> iterator
        """
        return _pilot.outstreamlist_erase(self, *args)

    def __init__(self, *args): 
        """
        __init__(self) -> outstreamlist
        __init__(self, outstreamlist arg0) -> outstreamlist
        __init__(self, size_type size) -> outstreamlist
        __init__(self, size_type size, value_type value) -> outstreamlist
        """
        this = _pilot.new_outstreamlist(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args):
        """push_back(self, value_type x)"""
        return _pilot.outstreamlist_push_back(self, *args)

    def front(self):
        """front(self) -> value_type"""
        return _pilot.outstreamlist_front(self)

    def back(self):
        """back(self) -> value_type"""
        return _pilot.outstreamlist_back(self)

    def assign(self, *args):
        """assign(self, size_type n, value_type x)"""
        return _pilot.outstreamlist_assign(self, *args)

    def resize(self, *args):
        """
        resize(self, size_type new_size)
        resize(self, size_type new_size, value_type x)
        """
        return _pilot.outstreamlist_resize(self, *args)

    def insert(self, *args):
        """
        insert(self, iterator pos, value_type x) -> iterator
        insert(self, iterator pos, size_type n, value_type x)
        """
        return _pilot.outstreamlist_insert(self, *args)

    def pop_front(self):
        """pop_front(self)"""
        return _pilot.outstreamlist_pop_front(self)

    def push_front(self, *args):
        """push_front(self, value_type x)"""
        return _pilot.outstreamlist_push_front(self, *args)

    def remove(self, *args):
        """remove(self, value_type x)"""
        return _pilot.outstreamlist_remove(self, *args)

    def unique(self):
        """unique(self)"""
        return _pilot.outstreamlist_unique(self)

    def reverse(self):
        """reverse(self)"""
        return _pilot.outstreamlist_reverse(self)

    def sort(self):
        """sort(self)"""
        return _pilot.outstreamlist_sort(self)

    def merge(self, *args):
        """merge(self, outstreamlist x)"""
        return _pilot.outstreamlist_merge(self, *args)

    __swig_destroy__ = _pilot.delete_outstreamlist
    __del__ = lambda self : None;
outstreamlist_swigregister = _pilot.outstreamlist_swigregister
outstreamlist_swigregister(outstreamlist)

class loadermap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::CatalogLoader)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, loadermap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, loadermap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.loadermap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.loadermap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.loadermap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.loadermap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _pilot.loadermap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _pilot.loadermap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _pilot.loadermap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.loadermap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _pilot.loadermap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _pilot.loadermap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _pilot.loadermap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.loadermap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.loadermap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _pilot.loadermap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> loadermap
        __init__(self) -> loadermap
        __init__(self, loadermap arg0) -> loadermap
        """
        this = _pilot.new_loadermap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _pilot.loadermap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.loadermap_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.loadermap_clear(self)

    def swap(self, *args):
        """swap(self, loadermap v)"""
        return _pilot.loadermap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.loadermap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.loadermap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.loadermap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.loadermap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.loadermap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _pilot.loadermap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _pilot.loadermap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _pilot.loadermap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _pilot.loadermap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _pilot.loadermap_upper_bound(self, *args)

    __swig_destroy__ = _pilot.delete_loadermap
    __del__ = lambda self : None;
loadermap_swigregister = _pilot.loadermap_swigregister
loadermap_swigregister(loadermap)

class composedmap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::ComposedNode)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, composedmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, composedmap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.composedmap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.composedmap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.composedmap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.composedmap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _pilot.composedmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _pilot.composedmap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _pilot.composedmap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.composedmap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _pilot.composedmap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _pilot.composedmap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _pilot.composedmap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.composedmap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.composedmap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _pilot.composedmap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> composedmap
        __init__(self) -> composedmap
        __init__(self, composedmap arg0) -> composedmap
        """
        this = _pilot.new_composedmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _pilot.composedmap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.composedmap_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.composedmap_clear(self)

    def swap(self, *args):
        """swap(self, composedmap v)"""
        return _pilot.composedmap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.composedmap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.composedmap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.composedmap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.composedmap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.composedmap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _pilot.composedmap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _pilot.composedmap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _pilot.composedmap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _pilot.composedmap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _pilot.composedmap_upper_bound(self, *args)

    __swig_destroy__ = _pilot.delete_composedmap
    __del__ = lambda self : None;
composedmap_swigregister = _pilot.composedmap_swigregister
composedmap_swigregister(composedmap)

class compomap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::ComponentDefinition)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, compomap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, compomap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.compomap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.compomap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.compomap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.compomap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _pilot.compomap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _pilot.compomap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _pilot.compomap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.compomap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _pilot.compomap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _pilot.compomap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _pilot.compomap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.compomap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.compomap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _pilot.compomap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> compomap
        __init__(self) -> compomap
        __init__(self, compomap arg0) -> compomap
        """
        this = _pilot.new_compomap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _pilot.compomap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.compomap_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.compomap_clear(self)

    def swap(self, *args):
        """swap(self, compomap v)"""
        return _pilot.compomap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.compomap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.compomap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.compomap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.compomap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.compomap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _pilot.compomap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _pilot.compomap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _pilot.compomap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _pilot.compomap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _pilot.compomap_upper_bound(self, *args)

    __swig_destroy__ = _pilot.delete_compomap
    __del__ = lambda self : None;
compomap_swigregister = _pilot.compomap_swigregister
compomap_swigregister(compomap)

class propmap(_object):
    """Proxy of C++ std::map<(std::string,std::string)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, propmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, propmap, name)
    __repr__ = _swig_repr
    def iterator(self):
        """iterator(self) -> pilot_PySwigIterator"""
        return _pilot.propmap_iterator(self)

    def __iter__(self): return self.iterator()
    def __nonzero__(self):
        """__nonzero__(self) -> bool"""
        return _pilot.propmap___nonzero__(self)

    def __bool__(self):
        """__bool__(self) -> bool"""
        return _pilot.propmap___bool__(self)

    def __len__(self):
        """__len__(self) -> size_type"""
        return _pilot.propmap___len__(self)

    def __getitem__(self, *args):
        """__getitem__(self, key_type key) -> mapped_type"""
        return _pilot.propmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, key_type key)"""
        return _pilot.propmap___delitem__(self, *args)

    def has_key(self, *args):
        """has_key(self, key_type key) -> bool"""
        return _pilot.propmap_has_key(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.propmap_keys(self)

    def values(self):
        """values(self) -> PyObject"""
        return _pilot.propmap_values(self)

    def items(self):
        """items(self) -> PyObject"""
        return _pilot.propmap_items(self)

    def __contains__(self, *args):
        """__contains__(self, key_type key) -> bool"""
        return _pilot.propmap___contains__(self, *args)

    def key_iterator(self):
        """key_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.propmap_key_iterator(self)

    def value_iterator(self):
        """value_iterator(self) -> pilot_PySwigIterator"""
        return _pilot.propmap_value_iterator(self)

    def __iter__(self): return self.key_iterator()
    def iterkeys(self): return self.key_iterator()
    def itervalues(self): return self.value_iterator()
    def iteritems(self): return self.iterator()
    def __setitem__(self, *args):
        """__setitem__(self, key_type key, mapped_type x)"""
        return _pilot.propmap___setitem__(self, *args)

    def __init__(self, *args): 
        """
        __init__(self, std::less<(std::string)> arg0) -> propmap
        __init__(self) -> propmap
        __init__(self, propmap arg0) -> propmap
        """
        this = _pilot.new_propmap(*args)
        try: self.this.append(this)
        except: self.this = this
    def empty(self):
        """empty(self) -> bool"""
        return _pilot.propmap_empty(self)

    def size(self):
        """size(self) -> size_type"""
        return _pilot.propmap_size(self)

    def clear(self):
        """clear(self)"""
        return _pilot.propmap_clear(self)

    def swap(self, *args):
        """swap(self, propmap v)"""
        return _pilot.propmap_swap(self, *args)

    def get_allocator(self):
        """get_allocator(self) -> allocator_type"""
        return _pilot.propmap_get_allocator(self)

    def begin(self):
        """begin(self) -> const_iterator"""
        return _pilot.propmap_begin(self)

    def end(self):
        """end(self) -> const_iterator"""
        return _pilot.propmap_end(self)

    def rbegin(self):
        """rbegin(self) -> const_reverse_iterator"""
        return _pilot.propmap_rbegin(self)

    def rend(self):
        """rend(self) -> const_reverse_iterator"""
        return _pilot.propmap_rend(self)

    def count(self, *args):
        """count(self, key_type x) -> size_type"""
        return _pilot.propmap_count(self, *args)

    def erase(self, *args):
        """
        erase(self, key_type x) -> size_type
        erase(self, iterator position)
        erase(self, iterator first, iterator last)
        """
        return _pilot.propmap_erase(self, *args)

    def find(self, *args):
        """find(self, key_type x) -> iterator"""
        return _pilot.propmap_find(self, *args)

    def lower_bound(self, *args):
        """lower_bound(self, key_type x) -> iterator"""
        return _pilot.propmap_lower_bound(self, *args)

    def upper_bound(self, *args):
        """upper_bound(self, key_type x) -> iterator"""
        return _pilot.propmap_upper_bound(self, *args)

    __swig_destroy__ = _pilot.delete_propmap
    __del__ = lambda self : None;
propmap_swigregister = _pilot.propmap_swigregister
propmap_swigregister(propmap)

class CompoInstmap(_object):
    """Proxy of C++ std::map<(std::string,p.YACS::ENGINE::ComponentInstance)> class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CompoInstmap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CompoInstmap, name)
    __repr__ = _swig_repr
    def __setitem__(self, *args):
        """__setitem__(self, string name, ComponentInstance c)"""
        return _pilot.CompoInstmap___setitem__(self, *args)

    def __getitem__(self, *args):
        """__getitem__(self, string name) -> ComponentInstance"""
        return _pilot.CompoInstmap___getitem__(self, *args)

    def __delitem__(self, *args):
        """__delitem__(self, string name)"""
        return _pilot.CompoInstmap___delitem__(self, *args)

    def keys(self):
        """keys(self) -> PyObject"""
        return _pilot.CompoInstmap_keys(self)

    def __init__(self): 
        """__init__(self) -> CompoInstmap"""
        this = _pilot.new_CompoInstmap()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_CompoInstmap
    __del__ = lambda self : None;
CompoInstmap_swigregister = _pilot.CompoInstmap_swigregister
CompoInstmap_swigregister(CompoInstmap)

from UserDict import DictMixin
class CompoInstmap(CompoInstmap,DictMixin):pass
CompoInstmap_swigregister(CompoInstmap)

White = _pilot.White
Grey = _pilot.Grey
Black = _pilot.Black
UNDEFINED = _pilot.UNDEFINED
INVALID = _pilot.INVALID
READY = _pilot.READY
TOLOAD = _pilot.TOLOAD
LOADED = _pilot.LOADED
TOACTIVATE = _pilot.TOACTIVATE
ACTIVATED = _pilot.ACTIVATED
DESACTIVATED = _pilot.DESACTIVATED
DONE = _pilot.DONE
SUSPENDED = _pilot.SUSPENDED
LOADFAILED = _pilot.LOADFAILED
EXECFAILED = _pilot.EXECFAILED
PAUSE = _pilot.PAUSE
INTERNALERR = _pilot.INTERNALERR
DISABLED = _pilot.DISABLED
FAILED = _pilot.FAILED
ERROR = _pilot.ERROR
NOEVENT = _pilot.NOEVENT
START = _pilot.START
FINISH = _pilot.FINISH
ABORT = _pilot.ABORT
NOTYETINITIALIZED = _pilot.NOTYETINITIALIZED
INITIALISED = _pilot.INITIALISED
RUNNING = _pilot.RUNNING
WAITINGTASKS = _pilot.WAITINGTASKS
PAUSED = _pilot.PAUSED
FINISHED = _pilot.FINISHED
STOPPED = _pilot.STOPPED
CONTINUE = _pilot.CONTINUE
STEPBYSTEP = _pilot.STEPBYSTEP
STOPBEFORENODES = _pilot.STOPBEFORENODES
class Exception(_object):
    """Proxy of C++ YACS::Exception class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Exception, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Exception, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string what) -> Exception"""
        this = _pilot.new_Exception(*args)
        try: self.this.append(this)
        except: self.this = this
    def what(self):
        """what(self) -> char"""
        return _pilot.Exception_what(self)

    __swig_destroy__ = _pilot.delete_Exception
    __del__ = lambda self : None;
Exception_swigregister = _pilot.Exception_swigregister
Exception_swigregister(Exception)

class DrivenConditionPT(_object):
    """Proxy of C++ YACS::BASES::DrivenConditionPT class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DrivenConditionPT, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DrivenConditionPT, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> DrivenConditionPT"""
        this = _pilot.new_DrivenConditionPT()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_DrivenConditionPT
    __del__ = lambda self : None;
    def waitForAWait(self):
        """waitForAWait(self)"""
        return _pilot.DrivenConditionPT_waitForAWait(self)

    def notifyOneSync(self):
        """notifyOneSync(self)"""
        return _pilot.DrivenConditionPT_notifyOneSync(self)

    def wait(self):
        """wait(self)"""
        return _pilot.DrivenConditionPT_wait(self)

    def signal(self):
        """signal(self)"""
        return _pilot.DrivenConditionPT_signal(self)

DrivenConditionPT_swigregister = _pilot.DrivenConditionPT_swigregister
DrivenConditionPT_swigregister(DrivenConditionPT)

class ConversionException(Exception):
    """Proxy of C++ YACS::ENGINE::ConversionException class"""
    __swig_setmethods__ = {}
    for _s in [Exception]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConversionException, name, value)
    __swig_getmethods__ = {}
    for _s in [Exception]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConversionException, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string what, bool prefix = True) -> ConversionException
        __init__(self, string what) -> ConversionException
        """
        this = _pilot.new_ConversionException(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_ConversionException
    __del__ = lambda self : None;
ConversionException_swigregister = _pilot.ConversionException_swigregister
ConversionException_swigregister(ConversionException)


def getRuntime():
  """getRuntime() -> Runtime"""
  return _pilot.getRuntime()
class Runtime(_object):
    """Proxy of C++ YACS::ENGINE::Runtime class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Runtime, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Runtime, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def init(self):
        """init(self)"""
        return _pilot.Runtime_init(self)

    def fini(self):
        """fini(self)"""
        return _pilot.Runtime_fini(self)

    def loadCatalog(self, *args):
        """loadCatalog(self, string sourceKind, string path) -> Catalog"""
        return _pilot.Runtime_loadCatalog(self, *args)

    def createFuncNode(self, *args):
        """createFuncNode(self, string kind, string name) -> InlineFuncNode"""
        return _pilot.Runtime_createFuncNode(self, *args)

    def createScriptNode(self, *args):
        """createScriptNode(self, string kind, string name) -> InlineNode"""
        return _pilot.Runtime_createScriptNode(self, *args)

    def createRefNode(self, *args):
        """createRefNode(self, string kind, string name) -> ServiceNode"""
        return _pilot.Runtime_createRefNode(self, *args)

    def createCompoNode(self, *args):
        """createCompoNode(self, string kind, string name) -> ServiceNode"""
        return _pilot.Runtime_createCompoNode(self, *args)

    def createSInlineNode(self, *args):
        """createSInlineNode(self, string kind, string name) -> ServiceInlineNode"""
        return _pilot.Runtime_createSInlineNode(self, *args)

    def createInDataNode(self, *args):
        """createInDataNode(self, string kind, string name) -> DataNode"""
        return _pilot.Runtime_createInDataNode(self, *args)

    def createOutDataNode(self, *args):
        """createOutDataNode(self, string kind, string name) -> DataNode"""
        return _pilot.Runtime_createOutDataNode(self, *args)

    def createComponentInstance(self, *args):
        """
        createComponentInstance(self, string name, string kind = "") -> ComponentInstance
        createComponentInstance(self, string name) -> ComponentInstance
        """
        return _pilot.Runtime_createComponentInstance(self, *args)

    def createContainer(self, kind = ""):
        """
        createContainer(self, string kind = "") -> Container
        createContainer(self) -> Container
        """
        return _pilot.Runtime_createContainer(self, kind)

    def createProc(self, *args):
        """createProc(self, string name) -> Proc"""
        return _pilot.Runtime_createProc(self, *args)

    def createBloc(self, *args):
        """createBloc(self, string name) -> Bloc"""
        return _pilot.Runtime_createBloc(self, *args)

    def createWhileLoop(self, *args):
        """createWhileLoop(self, string name) -> WhileLoop"""
        return _pilot.Runtime_createWhileLoop(self, *args)

    def createForLoop(self, *args):
        """createForLoop(self, string name) -> ForLoop"""
        return _pilot.Runtime_createForLoop(self, *args)

    def createForEachLoop(self, *args):
        """createForEachLoop(self, string name, TypeCode type) -> ForEachLoop"""
        return _pilot.Runtime_createForEachLoop(self, *args)

    def createOptimizerLoop(self, *args):
        """
        createOptimizerLoop(self, string name, string algLib, string factoryName, bool algInitOnFile, 
            string kind = "") -> OptimizerLoop
        createOptimizerLoop(self, string name, string algLib, string factoryName, bool algInitOnFile) -> OptimizerLoop
        """
        return _pilot.Runtime_createOptimizerLoop(self, *args)

    def createSwitch(self, *args):
        """createSwitch(self, string name) -> Switch"""
        return _pilot.Runtime_createSwitch(self, *args)

    def createInterfaceTc(self, *args):
        """createInterfaceTc(self, string id, string name, std::list<(p.YACS::ENGINE::TypeCodeObjref,std::allocator<(p.YACS::ENGINE::TypeCodeObjref)>)> ltc) -> TypeCode"""
        return _pilot.Runtime_createInterfaceTc(self, *args)

    def createSequenceTc(self, *args):
        """createSequenceTc(self, string id, string name, TypeCode content) -> TypeCode"""
        return _pilot.Runtime_createSequenceTc(self, *args)

    def createStructTc(self, *args):
        """createStructTc(self, string id, string name) -> TypeCodeStruct"""
        return _pilot.Runtime_createStructTc(self, *args)

    def createInputPort(self, *args):
        """createInputPort(self, string name, string impl, Node node, TypeCode type) -> InputPort"""
        return _pilot.Runtime_createInputPort(self, *args)

    def createOutputPort(self, *args):
        """createOutputPort(self, string name, string impl, Node node, TypeCode type) -> OutputPort"""
        return _pilot.Runtime_createOutputPort(self, *args)

    def createInputDataStreamPort(self, *args):
        """createInputDataStreamPort(self, string name, Node node, TypeCode type) -> InputDataStreamPort"""
        return _pilot.Runtime_createInputDataStreamPort(self, *args)

    def createOutputDataStreamPort(self, *args):
        """createOutputDataStreamPort(self, string name, Node node, TypeCode type) -> OutputDataStreamPort"""
        return _pilot.Runtime_createOutputDataStreamPort(self, *args)

    def adapt(self, *args):
        """
        adapt(self, InputPort source, string impl, TypeCode type, bool init = False) -> InputPort
        adapt(self, InputPort source, string impl, TypeCode type) -> InputPort
        """
        return _pilot.Runtime_adapt(self, *args)

    def convertNeutral(self, *args):
        """convertNeutral(self, TypeCode type, Any data) -> void"""
        return _pilot.Runtime_convertNeutral(self, *args)

    def convertNeutralAsString(self, *args):
        """convertNeutralAsString(self, TypeCode type, Any data) -> string"""
        return _pilot.Runtime_convertNeutralAsString(self, *args)

    def removeRuntime(self):
        """removeRuntime(self)"""
        return _pilot.Runtime_removeRuntime(self)

    __swig_destroy__ = _pilot.delete_Runtime
    __del__ = lambda self : None;
    def setCatalogLoaderFactory(self, *args):
        """setCatalogLoaderFactory(self, string name, CatalogLoader factory)"""
        return _pilot.Runtime_setCatalogLoaderFactory(self, *args)

    __swig_setmethods__["_catalogLoaderFactoryMap"] = _pilot.Runtime__catalogLoaderFactoryMap_set
    __swig_getmethods__["_catalogLoaderFactoryMap"] = _pilot.Runtime__catalogLoaderFactoryMap_get
    if _newclass:_catalogLoaderFactoryMap = _swig_property(_pilot.Runtime__catalogLoaderFactoryMap_get, _pilot.Runtime__catalogLoaderFactoryMap_set)
    def getBuiltinCatalog(self):
        """getBuiltinCatalog(self) -> Catalog"""
        return _pilot.Runtime_getBuiltinCatalog(self)

    def addCatalog(self, *args):
        """addCatalog(self, Catalog catalog)"""
        return _pilot.Runtime_addCatalog(self, *args)

    def getTypeCode(self, *args):
        """getTypeCode(self, string name) -> TypeCode"""
        return _pilot.Runtime_getTypeCode(self, *args)

Runtime_swigregister = _pilot.Runtime_swigregister
Runtime_swigregister(Runtime)
cvar = _pilot.cvar
Runtime.RUNTIME_ENGINE_INTERACTION_IMPL_NAME = _pilot.cvar.Runtime_RUNTIME_ENGINE_INTERACTION_IMPL_NAME

class PropertyInterface(_object):
    """Proxy of C++ YACS::ENGINE::PropertyInterface class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PropertyInterface, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PropertyInterface, name)
    __repr__ = _swig_repr
    def setProperty(self, *args):
        """setProperty(self, string name, string value)"""
        return _pilot.PropertyInterface_setProperty(self, *args)

    def getProperty(self, *args):
        """getProperty(self, string name) -> string"""
        return _pilot.PropertyInterface_getProperty(self, *args)

    def getProperties(self):
        """getProperties(self) -> propmap"""
        return _pilot.PropertyInterface_getProperties(self)

    def setProperties(self, *args):
        """setProperties(self, propmap properties)"""
        return _pilot.PropertyInterface_setProperties(self, *args)

    def __init__(self): 
        """__init__(self) -> PropertyInterface"""
        this = _pilot.new_PropertyInterface()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_PropertyInterface
    __del__ = lambda self : None;
PropertyInterface_swigregister = _pilot.PropertyInterface_swigregister
PropertyInterface_swigregister(PropertyInterface)

class Executor(_object):
    """Proxy of C++ YACS::ENGINE::Executor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Executor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Executor, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> Executor"""
        this = _pilot.new_Executor()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_Executor
    __del__ = lambda self : None;
    def RunA(self, *args):
        """
        RunA(self, Scheduler graph, int debug = 0, bool fromScratch = True)
        RunA(self, Scheduler graph, int debug = 0)
        RunA(self, Scheduler graph)
        """
        return _pilot.Executor_RunA(self, *args)

    def RunW(self, *args):
        """
        RunW(self, Scheduler graph, int debug = 0, bool fromScratch = True)
        RunW(self, Scheduler graph, int debug = 0)
        RunW(self, Scheduler graph)
        """
        return _pilot.Executor_RunW(self, *args)

    def RunB(self, *args):
        """
        RunB(self, Scheduler graph, int debug = 0, bool fromScratch = True)
        RunB(self, Scheduler graph, int debug = 0)
        RunB(self, Scheduler graph)
        """
        return _pilot.Executor_RunB(self, *args)

    def getCurrentExecMode(self):
        """getCurrentExecMode(self) -> ExecutionMode"""
        return _pilot.Executor_getCurrentExecMode(self)

    def getExecutorState(self):
        """getExecutorState(self) -> ExecutorState"""
        return _pilot.Executor_getExecutorState(self)

    def setExecMode(self, *args):
        """setExecMode(self, ExecutionMode mode)"""
        return _pilot.Executor_setExecMode(self, *args)

    def setListOfBreakPoints(self, *args):
        """setListOfBreakPoints(self, __dummy_1__ listOfBreakPoints)"""
        return _pilot.Executor_setListOfBreakPoints(self, *args)

    def getTasksToLoad(self):
        """getTasksToLoad(self) -> __dummy_1__"""
        return _pilot.Executor_getTasksToLoad(self)

    def setStepsToExecute(self, *args):
        """setStepsToExecute(self, __dummy_1__ listToExecute) -> bool"""
        return _pilot.Executor_setStepsToExecute(self, *args)

    def resumeCurrentBreakPoint(self):
        """resumeCurrentBreakPoint(self) -> bool"""
        return _pilot.Executor_resumeCurrentBreakPoint(self)

    def isNotFinished(self):
        """isNotFinished(self) -> bool"""
        return _pilot.Executor_isNotFinished(self)

    def stopExecution(self):
        """stopExecution(self)"""
        return _pilot.Executor_stopExecution(self)

    def saveState(self, *args):
        """saveState(self, string xmlFile) -> bool"""
        return _pilot.Executor_saveState(self, *args)

    def loadState(self):
        """loadState(self) -> bool"""
        return _pilot.Executor_loadState(self)

    def getNbOfThreads(self):
        """getNbOfThreads(self) -> int"""
        return _pilot.Executor_getNbOfThreads(self)

    def displayDot(self, *args):
        """displayDot(self, Scheduler graph)"""
        return _pilot.Executor_displayDot(self, *args)

    def setStopOnError(self, dumpRequested = False, xmlFile = ""):
        """
        setStopOnError(self, bool dumpRequested = False, string xmlFile = "")
        setStopOnError(self, bool dumpRequested = False)
        setStopOnError(self)
        """
        return _pilot.Executor_setStopOnError(self, dumpRequested, xmlFile)

    def unsetStopOnError(self):
        """unsetStopOnError(self)"""
        return _pilot.Executor_unsetStopOnError(self)

    def waitPause(self):
        """waitPause(self)"""
        return _pilot.Executor_waitPause(self)

    __swig_setmethods__["_maxThreads"] = _pilot.Executor__maxThreads_set
    __swig_getmethods__["_maxThreads"] = _pilot.Executor__maxThreads_get
    if _newclass:_maxThreads = _swig_property(_pilot.Executor__maxThreads_get, _pilot.Executor__maxThreads_set)
Executor_swigregister = _pilot.Executor_swigregister
Executor_swigregister(Executor)

class ExecutorSwig(Executor):
    """Proxy of C++ YACS::ENGINE::ExecutorSwig class"""
    __swig_setmethods__ = {}
    for _s in [Executor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ExecutorSwig, name, value)
    __swig_getmethods__ = {}
    for _s in [Executor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ExecutorSwig, name)
    __repr__ = _swig_repr
    def RunPy(self, *args):
        """
        RunPy(self, Scheduler graph, int debug = 0, bool isPyThread = True, 
            bool fromscratch = True)
        RunPy(self, Scheduler graph, int debug = 0, bool isPyThread = True)
        RunPy(self, Scheduler graph, int debug = 0)
        RunPy(self, Scheduler graph)
        """
        return _pilot.ExecutorSwig_RunPy(self, *args)

    def waitPause(self):
        """waitPause(self)"""
        return _pilot.ExecutorSwig_waitPause(self)

    def __init__(self): 
        """__init__(self) -> ExecutorSwig"""
        this = _pilot.new_ExecutorSwig()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_ExecutorSwig
    __del__ = lambda self : None;
ExecutorSwig_swigregister = _pilot.ExecutorSwig_swigregister
ExecutorSwig_swigregister(ExecutorSwig)

class RefCounter(_object):
    """Proxy of C++ YACS::ENGINE::RefCounter class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RefCounter, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RefCounter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getRefCnt(self):
        """getRefCnt(self) -> unsigned int"""
        return _pilot.RefCounter_getRefCnt(self)

    def incrRef(self):
        """incrRef(self)"""
        return _pilot.RefCounter_incrRef(self)

    def decrRef(self):
        """decrRef(self) -> bool"""
        return _pilot.RefCounter_decrRef(self)

    __swig_setmethods__["_totalCnt"] = _pilot.RefCounter__totalCnt_set
    __swig_getmethods__["_totalCnt"] = _pilot.RefCounter__totalCnt_get
    if _newclass:_totalCnt = _swig_property(_pilot.RefCounter__totalCnt_get, _pilot.RefCounter__totalCnt_set)
RefCounter_swigregister = _pilot.RefCounter_swigregister
RefCounter_swigregister(RefCounter)

class StringOnHeap(_object):
    """Proxy of C++ YACS::ENGINE::StringOnHeap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StringOnHeap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StringOnHeap, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
StringOnHeap_swigregister = _pilot.StringOnHeap_swigregister
StringOnHeap_swigregister(StringOnHeap)

class Any(RefCounter):
    """Proxy of C++ YACS::ENGINE::Any class"""
    __swig_setmethods__ = {}
    for _s in [RefCounter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Any, name, value)
    __swig_getmethods__ = {}
    for _s in [RefCounter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Any, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getType(self):
        """getType(self) -> TypeCode"""
        return _pilot.Any_getType(self)

    def clone(self):
        """clone(self) -> Any"""
        return _pilot.Any_clone(self)

    def __eq__(self, *args):
        """__eq__(self, Any other) -> bool"""
        return _pilot.Any___eq__(self, *args)

    def getIntValue(self):
        """getIntValue(self) -> int"""
        return _pilot.Any_getIntValue(self)

    def getBoolValue(self):
        """getBoolValue(self) -> bool"""
        return _pilot.Any_getBoolValue(self)

    def getDoubleValue(self):
        """getDoubleValue(self) -> double"""
        return _pilot.Any_getDoubleValue(self)

    def getStringValue(self):
        """getStringValue(self) -> string"""
        return _pilot.Any_getStringValue(self)

    __swig_destroy__ = _pilot.delete_Any
    __del__ = lambda self : None;
Any_swigregister = _pilot.Any_swigregister
Any_swigregister(Any)

class AtomAny(Any):
    """Proxy of C++ YACS::ENGINE::AtomAny class"""
    __swig_setmethods__ = {}
    for _s in [Any]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AtomAny, name, value)
    __swig_getmethods__ = {}
    for _s in [Any]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AtomAny, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def clone(self):
        """clone(self) -> Any"""
        return _pilot.AtomAny_clone(self)

    def New(*args):
        """New(char val, Deallocator dealloc) -> AtomAny"""
        return _pilot.AtomAny_New(*args)

    if _newclass:New = staticmethod(New)
    __swig_getmethods__["New"] = lambda x: New
    def __eq__(self, *args):
        """__eq__(self, Any other) -> bool"""
        return _pilot.AtomAny___eq__(self, *args)

    def getIntValue(self):
        """getIntValue(self) -> int"""
        return _pilot.AtomAny_getIntValue(self)

    def getBoolValue(self):
        """getBoolValue(self) -> bool"""
        return _pilot.AtomAny_getBoolValue(self)

    def getDoubleValue(self):
        """getDoubleValue(self) -> double"""
        return _pilot.AtomAny_getDoubleValue(self)

    def getStringValue(self):
        """getStringValue(self) -> string"""
        return _pilot.AtomAny_getStringValue(self)

AtomAny_swigregister = _pilot.AtomAny_swigregister
AtomAny_swigregister(AtomAny)

def AtomAny_New(*args):
  """AtomAny_New(char val, Deallocator dealloc) -> AtomAny"""
  return _pilot.AtomAny_New(*args)

class SeqAlloc(_object):
    """Proxy of C++ YACS::ENGINE::SeqAlloc class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SeqAlloc, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SeqAlloc, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
SeqAlloc_swigregister = _pilot.SeqAlloc_swigregister
SeqAlloc_swigregister(SeqAlloc)

class ComposedAny(Any):
    """Proxy of C++ YACS::ENGINE::ComposedAny class"""
    __swig_setmethods__ = {}
    for _s in [Any]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComposedAny, name, value)
    __swig_getmethods__ = {}
    for _s in [Any]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComposedAny, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setEltAtRank(self, *args):
        """setEltAtRank(self, int i, Any elem)"""
        return _pilot.ComposedAny_setEltAtRank(self, *args)

    __swig_destroy__ = _pilot.delete_ComposedAny
    __del__ = lambda self : None;
ComposedAny_swigregister = _pilot.ComposedAny_swigregister
ComposedAny_swigregister(ComposedAny)

class SequenceAny(ComposedAny):
    """Proxy of C++ YACS::ENGINE::SequenceAny class"""
    __swig_setmethods__ = {}
    for _s in [ComposedAny]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SequenceAny, name, value)
    __swig_getmethods__ = {}
    for _s in [ComposedAny]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SequenceAny, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def clear(self):
        """clear(self)"""
        return _pilot.SequenceAny_clear(self)

    def popBack(self):
        """popBack(self)"""
        return _pilot.SequenceAny_popBack(self)

    def size(self):
        """size(self) -> unsigned int"""
        return _pilot.SequenceAny_size(self)

    def pushBack(self, *args):
        """pushBack(self, Any elem)"""
        return _pilot.SequenceAny_pushBack(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Any other) -> bool"""
        return _pilot.SequenceAny___eq__(self, *args)

    def setEltAtRank(self, *args):
        """setEltAtRank(self, int i, Any elem)"""
        return _pilot.SequenceAny_setEltAtRank(self, *args)

    def clone(self):
        """clone(self) -> Any"""
        return _pilot.SequenceAny_clone(self)

    def New(*args):
        """
        New(TypeCode typeOfContent) -> SequenceAny
        New(TypeCode typeOfContent, unsigned int lgth) -> SequenceAny
        """
        return _pilot.SequenceAny_New(*args)

    if _newclass:New = staticmethod(New)
    __swig_getmethods__["New"] = lambda x: New
    def __getitem__(self, *args):
        """__getitem__(self, int i) -> Any"""
        return _pilot.SequenceAny___getitem__(self, *args)

SequenceAny_swigregister = _pilot.SequenceAny_swigregister
SequenceAny_swigregister(SequenceAny)

def SequenceAny_New(*args):
  """
    New(TypeCode typeOfContent) -> SequenceAny
    SequenceAny_New(TypeCode typeOfContent, unsigned int lgth) -> SequenceAny
    """
  return _pilot.SequenceAny_New(*args)

class ArrayAny(ComposedAny):
    """Proxy of C++ YACS::ENGINE::ArrayAny class"""
    __swig_setmethods__ = {}
    for _s in [ComposedAny]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ArrayAny, name, value)
    __swig_getmethods__ = {}
    for _s in [ComposedAny]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ArrayAny, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setEltAtRank(self, *args):
        """setEltAtRank(self, int i, Any elem)"""
        return _pilot.ArrayAny_setEltAtRank(self, *args)

    def __eq__(self, *args):
        """__eq__(self, Any other) -> bool"""
        return _pilot.ArrayAny___eq__(self, *args)

    def size(self):
        """size(self) -> unsigned int"""
        return _pilot.ArrayAny_size(self)

    def clone(self):
        """clone(self) -> Any"""
        return _pilot.ArrayAny_clone(self)

    def New(*args):
        """New(TypeCode typeOfContent, unsigned int lgth) -> ArrayAny"""
        return _pilot.ArrayAny_New(*args)

    if _newclass:New = staticmethod(New)
    __swig_getmethods__["New"] = lambda x: New
ArrayAny_swigregister = _pilot.ArrayAny_swigregister
ArrayAny_swigregister(ArrayAny)

def ArrayAny_New(*args):
  """ArrayAny_New(TypeCode typeOfContent, unsigned int lgth) -> ArrayAny"""
  return _pilot.ArrayAny_New(*args)

class StructAny(ComposedAny):
    """Proxy of C++ YACS::ENGINE::StructAny class"""
    __swig_setmethods__ = {}
    for _s in [ComposedAny]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StructAny, name, value)
    __swig_getmethods__ = {}
    for _s in [ComposedAny]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StructAny, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def clone(self):
        """clone(self) -> Any"""
        return _pilot.StructAny_clone(self)

    def __eq__(self, *args):
        """__eq__(self, Any other) -> bool"""
        return _pilot.StructAny___eq__(self, *args)

    def New(*args):
        """New(TypeCodeStruct type) -> StructAny"""
        return _pilot.StructAny_New(*args)

    if _newclass:New = staticmethod(New)
    __swig_getmethods__["New"] = lambda x: New
    def setEltAtRank(self, *args):
        """
        setEltAtRank(self, int i, Any elem)
        setEltAtRank(self, char key, Any elem)
        """
        return _pilot.StructAny_setEltAtRank(self, *args)

StructAny_swigregister = _pilot.StructAny_swigregister
StructAny_swigregister(StructAny)

def StructAny_New(*args):
  """StructAny_New(TypeCodeStruct type) -> StructAny"""
  return _pilot.StructAny_New(*args)

NONE = _pilot.NONE
Double = _pilot.Double
Int = _pilot.Int
String = _pilot.String
Bool = _pilot.Bool
Objref = _pilot.Objref
Sequence = _pilot.Sequence
Array = _pilot.Array
Struct = _pilot.Struct
class TypeCode(RefCounter):
    """Proxy of C++ YACS::ENGINE::TypeCode class"""
    __swig_setmethods__ = {}
    for _s in [RefCounter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypeCode, name, value)
    __swig_getmethods__ = {}
    for _s in [RefCounter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypeCode, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, DynType kind) -> TypeCode"""
        this = _pilot.new_TypeCode(*args)
        try: self.this.append(this)
        except: self.this = this
    def kind(self):
        """kind(self) -> DynType"""
        return _pilot.TypeCode_kind(self)

    def clone(self):
        """clone(self) -> TypeCode"""
        return _pilot.TypeCode_clone(self)

    def putReprAtPlace(self, *args):
        """putReprAtPlace(self, char pt, char val, bool deepCpy)"""
        return _pilot.TypeCode_putReprAtPlace(self, *args)

    def destroyZippedAny(self, *args):
        """destroyZippedAny(self, char data)"""
        return _pilot.TypeCode_destroyZippedAny(self, *args)

    def name(self):
        """name(self) -> char"""
        return _pilot.TypeCode_name(self)

    def shortName(self):
        """shortName(self) -> char"""
        return _pilot.TypeCode_shortName(self)

    def id(self):
        """id(self) -> char"""
        return _pilot.TypeCode_id(self)

    def contentType(self):
        """contentType(self) -> TypeCode"""
        return _pilot.TypeCode_contentType(self)

    def isA(self, *args):
        """
        isA(self, char repositoryId) -> int
        isA(self, TypeCode tc) -> int
        """
        return _pilot.TypeCode_isA(self, *args)

    def isAdaptable(self, *args):
        """isAdaptable(self, TypeCode tc) -> int"""
        return _pilot.TypeCode_isAdaptable(self, *args)

    def isEquivalent(self, *args):
        """isEquivalent(self, TypeCode tc) -> int"""
        return _pilot.TypeCode_isEquivalent(self, *args)

    def getSizeInByteOfAnyReprInSeq(self):
        """getSizeInByteOfAnyReprInSeq(self) -> unsigned int"""
        return _pilot.TypeCode_getSizeInByteOfAnyReprInSeq(self)

    def getKindRepr(*args):
        """
        getKindRepr() -> char
        getKindRepr(DynType kind) -> char
        """
        return _pilot.TypeCode_getKindRepr(*args)

    if _newclass:getKindRepr = staticmethod(getKindRepr)
    __swig_getmethods__["getKindRepr"] = lambda x: getKindRepr
    def interfaceTc(*args):
        """
        interfaceTc(char id, char name) -> TypeCode
        interfaceTc(char id, char name, std::list<(p.YACS::ENGINE::TypeCodeObjref,std::allocator<(p.YACS::ENGINE::TypeCodeObjref)>)> ltc) -> TypeCode
        """
        return _pilot.TypeCode_interfaceTc(*args)

    if _newclass:interfaceTc = staticmethod(interfaceTc)
    __swig_getmethods__["interfaceTc"] = lambda x: interfaceTc
    def sequenceTc(*args):
        """sequenceTc(char id, char name, TypeCode content) -> TypeCode"""
        return _pilot.TypeCode_sequenceTc(*args)

    if _newclass:sequenceTc = staticmethod(sequenceTc)
    __swig_getmethods__["sequenceTc"] = lambda x: sequenceTc
    def structTc(*args):
        """structTc(char id, char name) -> TypeCode"""
        return _pilot.TypeCode_structTc(*args)

    if _newclass:structTc = staticmethod(structTc)
    __swig_getmethods__["structTc"] = lambda x: structTc
    __swig_destroy__ = _pilot.delete_TypeCode
    __del__ = lambda self : None;
TypeCode_swigregister = _pilot.TypeCode_swigregister
TypeCode_swigregister(TypeCode)

def TypeCode_getKindRepr(*args):
  """
    getKindRepr() -> char
    TypeCode_getKindRepr(DynType kind) -> char
    """
  return _pilot.TypeCode_getKindRepr(*args)

def TypeCode_interfaceTc(*args):
  """
    interfaceTc(char id, char name) -> TypeCode
    TypeCode_interfaceTc(char id, char name, std::list<(p.YACS::ENGINE::TypeCodeObjref,std::allocator<(p.YACS::ENGINE::TypeCodeObjref)>)> ltc) -> TypeCode
    """
  return _pilot.TypeCode_interfaceTc(*args)

def TypeCode_sequenceTc(*args):
  """TypeCode_sequenceTc(char id, char name, TypeCode content) -> TypeCode"""
  return _pilot.TypeCode_sequenceTc(*args)

def TypeCode_structTc(*args):
  """TypeCode_structTc(char id, char name) -> TypeCode"""
  return _pilot.TypeCode_structTc(*args)

class TypeCodeComposed(TypeCode):
    """Proxy of C++ YACS::ENGINE::TypeCodeComposed class"""
    __swig_setmethods__ = {}
    for _s in [TypeCode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypeCodeComposed, name, value)
    __swig_getmethods__ = {}
    for _s in [TypeCode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypeCodeComposed, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_TypeCodeComposed
    __del__ = lambda self : None;
TypeCodeComposed_swigregister = _pilot.TypeCodeComposed_swigregister
TypeCodeComposed_swigregister(TypeCodeComposed)

class TypeCodeObjref(TypeCodeComposed):
    """Proxy of C++ YACS::ENGINE::TypeCodeObjref class"""
    __swig_setmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypeCodeObjref, name, value)
    __swig_getmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypeCodeObjref, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, char repositoryId, char name) -> TypeCodeObjref
        __init__(self, char repositoryId, char name, std::list<(p.YACS::ENGINE::TypeCodeObjref,std::allocator<(p.YACS::ENGINE::TypeCodeObjref)>)> ltc) -> TypeCodeObjref
        """
        this = _pilot.new_TypeCodeObjref(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """clone(self) -> TypeCode"""
        return _pilot.TypeCodeObjref_clone(self)

    def putReprAtPlace(self, *args):
        """putReprAtPlace(self, char pt, char val, bool deepCpy)"""
        return _pilot.TypeCodeObjref_putReprAtPlace(self, *args)

    def destroyZippedAny(self, *args):
        """destroyZippedAny(self, char data)"""
        return _pilot.TypeCodeObjref_destroyZippedAny(self, *args)

    def id(self):
        """id(self) -> char"""
        return _pilot.TypeCodeObjref_id(self)

    def name(self):
        """name(self) -> char"""
        return _pilot.TypeCodeObjref_name(self)

    def shortName(self):
        """shortName(self) -> char"""
        return _pilot.TypeCodeObjref_shortName(self)

    def isA(self, *args):
        """
        isA(self, char repositoryId) -> int
        isA(self, TypeCode tc) -> int
        """
        return _pilot.TypeCodeObjref_isA(self, *args)

    def isAdaptable(self, *args):
        """isAdaptable(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeObjref_isAdaptable(self, *args)

    def isEquivalent(self, *args):
        """isEquivalent(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeObjref_isEquivalent(self, *args)

    __swig_destroy__ = _pilot.delete_TypeCodeObjref
    __del__ = lambda self : None;
TypeCodeObjref_swigregister = _pilot.TypeCodeObjref_swigregister
TypeCodeObjref_swigregister(TypeCodeObjref)

class TypeCodeSeq(TypeCodeComposed):
    """Proxy of C++ YACS::ENGINE::TypeCodeSeq class"""
    __swig_setmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypeCodeSeq, name, value)
    __swig_getmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypeCodeSeq, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char repositoryId, char name, TypeCode content) -> TypeCodeSeq"""
        this = _pilot.new_TypeCodeSeq(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """clone(self) -> TypeCode"""
        return _pilot.TypeCodeSeq_clone(self)

    def putReprAtPlace(self, *args):
        """putReprAtPlace(self, char pt, char val, bool deepCpy)"""
        return _pilot.TypeCodeSeq_putReprAtPlace(self, *args)

    def destroyZippedAny(self, *args):
        """destroyZippedAny(self, char data)"""
        return _pilot.TypeCodeSeq_destroyZippedAny(self, *args)

    def getSizeInByteOfAnyReprInSeq(self):
        """getSizeInByteOfAnyReprInSeq(self) -> unsigned int"""
        return _pilot.TypeCodeSeq_getSizeInByteOfAnyReprInSeq(self)

    def id(self):
        """id(self) -> char"""
        return _pilot.TypeCodeSeq_id(self)

    def name(self):
        """name(self) -> char"""
        return _pilot.TypeCodeSeq_name(self)

    def shortName(self):
        """shortName(self) -> char"""
        return _pilot.TypeCodeSeq_shortName(self)

    def contentType(self):
        """contentType(self) -> TypeCode"""
        return _pilot.TypeCodeSeq_contentType(self)

    def isA(self, *args):
        """isA(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeSeq_isA(self, *args)

    def isAdaptable(self, *args):
        """isAdaptable(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeSeq_isAdaptable(self, *args)

    def isEquivalent(self, *args):
        """isEquivalent(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeSeq_isEquivalent(self, *args)

    __swig_destroy__ = _pilot.delete_TypeCodeSeq
    __del__ = lambda self : None;
TypeCodeSeq_swigregister = _pilot.TypeCodeSeq_swigregister
TypeCodeSeq_swigregister(TypeCodeSeq)

class TypeCodeArray(TypeCodeComposed):
    """Proxy of C++ YACS::ENGINE::TypeCodeArray class"""
    __swig_setmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypeCodeArray, name, value)
    __swig_getmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypeCodeArray, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char repositoryId, char name, TypeCode content, unsigned int staticLgth) -> TypeCodeArray"""
        this = _pilot.new_TypeCodeArray(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """clone(self) -> TypeCode"""
        return _pilot.TypeCodeArray_clone(self)

    def putReprAtPlace(self, *args):
        """putReprAtPlace(self, char pt, char val, bool deepCpy)"""
        return _pilot.TypeCodeArray_putReprAtPlace(self, *args)

    def destroyZippedAny(self, *args):
        """destroyZippedAny(self, char data)"""
        return _pilot.TypeCodeArray_destroyZippedAny(self, *args)

    def id(self):
        """id(self) -> char"""
        return _pilot.TypeCodeArray_id(self)

    def name(self):
        """name(self) -> char"""
        return _pilot.TypeCodeArray_name(self)

    def shortName(self):
        """shortName(self) -> char"""
        return _pilot.TypeCodeArray_shortName(self)

    def getStaticLgth(self):
        """getStaticLgth(self) -> unsigned int"""
        return _pilot.TypeCodeArray_getStaticLgth(self)

    def contentType(self):
        """contentType(self) -> TypeCode"""
        return _pilot.TypeCodeArray_contentType(self)

    def isA(self, *args):
        """isA(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeArray_isA(self, *args)

    def isAdaptable(self, *args):
        """isAdaptable(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeArray_isAdaptable(self, *args)

    def isEquivalent(self, *args):
        """isEquivalent(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeArray_isEquivalent(self, *args)

    def getSizeInByteOfAnyReprInSeq(self):
        """getSizeInByteOfAnyReprInSeq(self) -> unsigned int"""
        return _pilot.TypeCodeArray_getSizeInByteOfAnyReprInSeq(self)

    __swig_destroy__ = _pilot.delete_TypeCodeArray
    __del__ = lambda self : None;
TypeCodeArray_swigregister = _pilot.TypeCodeArray_swigregister
TypeCodeArray_swigregister(TypeCodeArray)

class TypeCodeStruct(TypeCodeComposed):
    """Proxy of C++ YACS::ENGINE::TypeCodeStruct class"""
    __swig_setmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TypeCodeStruct, name, value)
    __swig_getmethods__ = {}
    for _s in [TypeCodeComposed]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TypeCodeStruct, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, char repositoryId, char name) -> TypeCodeStruct"""
        this = _pilot.new_TypeCodeStruct(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self):
        """clone(self) -> TypeCode"""
        return _pilot.TypeCodeStruct_clone(self)

    def putReprAtPlace(self, *args):
        """putReprAtPlace(self, char pt, char val, bool deepCpy)"""
        return _pilot.TypeCodeStruct_putReprAtPlace(self, *args)

    def destroyZippedAny(self, *args):
        """destroyZippedAny(self, char data)"""
        return _pilot.TypeCodeStruct_destroyZippedAny(self, *args)

    def id(self):
        """id(self) -> char"""
        return _pilot.TypeCodeStruct_id(self)

    def name(self):
        """name(self) -> char"""
        return _pilot.TypeCodeStruct_name(self)

    def shortName(self):
        """shortName(self) -> char"""
        return _pilot.TypeCodeStruct_shortName(self)

    def getSizeInByteOfAnyReprInSeq(self):
        """getSizeInByteOfAnyReprInSeq(self) -> unsigned int"""
        return _pilot.TypeCodeStruct_getSizeInByteOfAnyReprInSeq(self)

    def contentType(self):
        """contentType(self) -> TypeCode"""
        return _pilot.TypeCodeStruct_contentType(self)

    def isA(self, *args):
        """
        isA(self, char repositoryId) -> int
        isA(self, TypeCode tc) -> int
        """
        return _pilot.TypeCodeStruct_isA(self, *args)

    def isAdaptable(self, *args):
        """isAdaptable(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeStruct_isAdaptable(self, *args)

    def isEquivalent(self, *args):
        """isEquivalent(self, TypeCode tc) -> int"""
        return _pilot.TypeCodeStruct_isEquivalent(self, *args)

    def addMember(self, *args):
        """addMember(self, string name, TypeCode tc)"""
        return _pilot.TypeCodeStruct_addMember(self, *args)

    def getMember(self, *args):
        """getMember(self, string name, unsigned int offset) -> TypeCode"""
        return _pilot.TypeCodeStruct_getMember(self, *args)

    def memberCount(self):
        """memberCount(self) -> int"""
        return _pilot.TypeCodeStruct_memberCount(self)

    def memberName(self, *args):
        """memberName(self, int index) -> char"""
        return _pilot.TypeCodeStruct_memberName(self, *args)

    def memberType(self, *args):
        """memberType(self, int index) -> TypeCode"""
        return _pilot.TypeCodeStruct_memberType(self, *args)

    __swig_destroy__ = _pilot.delete_TypeCodeStruct
    __del__ = lambda self : None;
TypeCodeStruct_swigregister = _pilot.TypeCodeStruct_swigregister
TypeCodeStruct_swigregister(TypeCodeStruct)

class Scheduler(_object):
    """Proxy of C++ YACS::ENGINE::Scheduler class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Scheduler, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Scheduler, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.Scheduler_init(self, start)

    def isFinished(self):
        """isFinished(self) -> bool"""
        return _pilot.Scheduler_isFinished(self)

    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.Scheduler_exUpdateState(self)

    def getName(self):
        """getName(self) -> string"""
        return _pilot.Scheduler_getName(self)

    def getTaskName(self, *args):
        """getTaskName(self, Task task) -> string"""
        return _pilot.Scheduler_getTaskName(self, *args)

    def getNextTasks(self, *args):
        """getNextTasks(self, bool isMore) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.Scheduler_getNextTasks(self, *args)

    def selectRunnableTasks(self, *args):
        """selectRunnableTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Scheduler_selectRunnableTasks(self, *args)

    def notifyFrom(self, *args):
        """notifyFrom(self, Task sender, Event event)"""
        return _pilot.Scheduler_notifyFrom(self, *args)

    def getDeploymentTree(self):
        """getDeploymentTree(self) -> DeploymentTree"""
        return _pilot.Scheduler_getDeploymentTree(self)

    def isPlacementPredictableB4Run(self):
        """isPlacementPredictableB4Run(self) -> bool"""
        return _pilot.Scheduler_isPlacementPredictableB4Run(self)

    def isMultiplicitySpecified(self, *args):
        """isMultiplicitySpecified(self, unsigned int value) -> bool"""
        return _pilot.Scheduler_isMultiplicitySpecified(self, *args)

    def forceMultiplicity(self, *args):
        """forceMultiplicity(self, unsigned int value)"""
        return _pilot.Scheduler_forceMultiplicity(self, *args)

    __swig_destroy__ = _pilot.delete_Scheduler
    __del__ = lambda self : None;
Scheduler_swigregister = _pilot.Scheduler_swigregister
Scheduler_swigregister(Scheduler)

class Task(_object):
    """Proxy of C++ YACS::ENGINE::Task class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Task, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Task, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def begin(self):
        """begin(self)"""
        return _pilot.Task_begin(self)

    def isReady(self):
        """isReady(self) -> bool"""
        return _pilot.Task_isReady(self)

    def execute(self):
        """execute(self)"""
        return _pilot.Task_execute(self)

    def load(self):
        """load(self)"""
        return _pilot.Task_load(self)

    def loaded(self):
        """loaded(self)"""
        return _pilot.Task_loaded(self)

    def connected(self):
        """connected(self)"""
        return _pilot.Task_connected(self)

    def initService(self):
        """initService(self)"""
        return _pilot.Task_initService(self)

    def connectService(self):
        """connectService(self)"""
        return _pilot.Task_connectService(self)

    def disconnectService(self):
        """disconnectService(self)"""
        return _pilot.Task_disconnectService(self)

    def getCoupledTasks(self, *args):
        """getCoupledTasks(self, std::set<(p.YACS::ENGINE::Task,std::less<(p.YACS::ENGINE::Task)>,std::allocator<(p.YACS::ENGINE::Task)>)> coupledSet)"""
        return _pilot.Task_getCoupledTasks(self, *args)

    def isDeployable(self):
        """isDeployable(self) -> bool"""
        return _pilot.Task_isDeployable(self)

    def getComponent(self):
        """getComponent(self) -> ComponentInstance"""
        return _pilot.Task_getComponent(self)

    def getContainer(self):
        """getContainer(self) -> Container"""
        return _pilot.Task_getContainer(self)

    def getState(self):
        """getState(self) -> StatesForNode"""
        return _pilot.Task_getState(self)

    def finished(self):
        """finished(self)"""
        return _pilot.Task_finished(self)

    def aborted(self):
        """aborted(self)"""
        return _pilot.Task_aborted(self)

    __swig_destroy__ = _pilot.delete_Task
    __del__ = lambda self : None;
Task_swigregister = _pilot.Task_swigregister
Task_swigregister(Task)

class Observer(_object):
    """Proxy of C++ YACS::ENGINE::Observer class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Observer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Observer, name)
    __repr__ = _swig_repr
    def notifyObserver(self, *args):
        """notifyObserver(self, Node object, string event)"""
        return _pilot.Observer_notifyObserver(self, *args)

    __swig_destroy__ = _pilot.delete_Observer
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> Observer"""
        this = _pilot.new_Observer()
        try: self.this.append(this)
        except: self.this = this
Observer_swigregister = _pilot.Observer_swigregister
Observer_swigregister(Observer)

class Dispatcher(_object):
    """Proxy of C++ YACS::ENGINE::Dispatcher class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Dispatcher, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Dispatcher, name)
    __repr__ = _swig_repr
    def dispatch(self, *args):
        """dispatch(self, Node object, string event)"""
        return _pilot.Dispatcher_dispatch(self, *args)

    def addObserver(self, *args):
        """addObserver(self, Observer observer, Node object, string event)"""
        return _pilot.Dispatcher_addObserver(self, *args)

    def removeObserver(self, *args):
        """removeObserver(self, Observer observer, Node object, string event)"""
        return _pilot.Dispatcher_removeObserver(self, *args)

    def printObservers(self):
        """printObservers(self)"""
        return _pilot.Dispatcher_printObservers(self)

    def getDispatcher():
        """getDispatcher() -> Dispatcher"""
        return _pilot.Dispatcher_getDispatcher()

    if _newclass:getDispatcher = staticmethod(getDispatcher)
    __swig_getmethods__["getDispatcher"] = lambda x: getDispatcher
    def setDispatcher(*args):
        """setDispatcher(Dispatcher dispatcher)"""
        return _pilot.Dispatcher_setDispatcher(*args)

    if _newclass:setDispatcher = staticmethod(setDispatcher)
    __swig_getmethods__["setDispatcher"] = lambda x: setDispatcher
    __swig_destroy__ = _pilot.delete_Dispatcher
    __del__ = lambda self : None;
    def __init__(self): 
        """__init__(self) -> Dispatcher"""
        this = _pilot.new_Dispatcher()
        try: self.this.append(this)
        except: self.this = this
Dispatcher_swigregister = _pilot.Dispatcher_swigregister
Dispatcher_swigregister(Dispatcher)

def Dispatcher_getDispatcher():
  """Dispatcher_getDispatcher() -> Dispatcher"""
  return _pilot.Dispatcher_getDispatcher()

def Dispatcher_setDispatcher(*args):
  """Dispatcher_setDispatcher(Dispatcher dispatcher)"""
  return _pilot.Dispatcher_setDispatcher(*args)

class DeploymentTreeOnHeap(_object):
    """Proxy of C++ YACS::ENGINE::DeploymentTreeOnHeap class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DeploymentTreeOnHeap, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DeploymentTreeOnHeap, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> DeploymentTreeOnHeap"""
        this = _pilot.new_DeploymentTreeOnHeap()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_DeploymentTreeOnHeap
    __del__ = lambda self : None;
    def decrRef(self):
        """decrRef(self) -> bool"""
        return _pilot.DeploymentTreeOnHeap_decrRef(self)

    def incrRef(self):
        """incrRef(self)"""
        return _pilot.DeploymentTreeOnHeap_incrRef(self)

    def appendTask(self, *args):
        """appendTask(self, Task task, Scheduler cloner) -> unsigned char"""
        return _pilot.DeploymentTreeOnHeap_appendTask(self, *args)

    def getNumberOfCTDefContainer(self):
        """getNumberOfCTDefContainer(self) -> unsigned int"""
        return _pilot.DeploymentTreeOnHeap_getNumberOfCTDefContainer(self)

    def getNumberOfRTODefContainer(self):
        """getNumberOfRTODefContainer(self) -> unsigned int"""
        return _pilot.DeploymentTreeOnHeap_getNumberOfRTODefContainer(self)

    def getNumberOfCTDefComponentInstances(self):
        """getNumberOfCTDefComponentInstances(self) -> unsigned int"""
        return _pilot.DeploymentTreeOnHeap_getNumberOfCTDefComponentInstances(self)

    def getNumberOfRTODefComponentInstances(self):
        """getNumberOfRTODefComponentInstances(self) -> unsigned int"""
        return _pilot.DeploymentTreeOnHeap_getNumberOfRTODefComponentInstances(self)

    def getAllContainers(self):
        """getAllContainers(self) -> std::vector<(p.YACS::ENGINE::Container,std::allocator<(p.YACS::ENGINE::Container)>)>"""
        return _pilot.DeploymentTreeOnHeap_getAllContainers(self)

    def getAllCTDefContainers(self):
        """getAllCTDefContainers(self) -> std::vector<(p.YACS::ENGINE::Container,std::allocator<(p.YACS::ENGINE::Container)>)>"""
        return _pilot.DeploymentTreeOnHeap_getAllCTDefContainers(self)

    def getAllRTODefContainers(self):
        """getAllRTODefContainers(self) -> std::vector<(p.YACS::ENGINE::Container,std::allocator<(p.YACS::ENGINE::Container)>)>"""
        return _pilot.DeploymentTreeOnHeap_getAllRTODefContainers(self)

    def getTasksLinkedToComponent(self, *args):
        """getTasksLinkedToComponent(self, ComponentInstance comp) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.DeploymentTreeOnHeap_getTasksLinkedToComponent(self, *args)

    def getTasksLinkedToContainer(self, *args):
        """getTasksLinkedToContainer(self, Container cont) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.DeploymentTreeOnHeap_getTasksLinkedToContainer(self, *args)

    def getComponentsLinkedToContainer(self, *args):
        """getComponentsLinkedToContainer(self, Container cont) -> std::vector<(p.YACS::ENGINE::ComponentInstance,std::allocator<(p.YACS::ENGINE::ComponentInstance)>)>"""
        return _pilot.DeploymentTreeOnHeap_getComponentsLinkedToContainer(self, *args)

    def presenceOfDefaultContainer(self):
        """presenceOfDefaultContainer(self) -> bool"""
        return _pilot.DeploymentTreeOnHeap_presenceOfDefaultContainer(self)

    def getFreeDeployableTasks(self):
        """getFreeDeployableTasks(self) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.DeploymentTreeOnHeap_getFreeDeployableTasks(self)

DeploymentTreeOnHeap_swigregister = _pilot.DeploymentTreeOnHeap_swigregister
DeploymentTreeOnHeap_swigregister(DeploymentTreeOnHeap)

class DeploymentTree(_object):
    """Proxy of C++ YACS::ENGINE::DeploymentTree class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DeploymentTree, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DeploymentTree, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_DeploymentTree
    __del__ = lambda self : None;
    def __init__(self, *args): 
        """
        __init__(self) -> DeploymentTree
        __init__(self, DeploymentTree other) -> DeploymentTree
        """
        this = _pilot.new_DeploymentTree(*args)
        try: self.this.append(this)
        except: self.this = this
    def appendTask(self, *args):
        """appendTask(self, Task task, Scheduler cloner) -> unsigned char"""
        return _pilot.DeploymentTree_appendTask(self, *args)

    def getNumberOfCTDefContainer(self):
        """getNumberOfCTDefContainer(self) -> unsigned int"""
        return _pilot.DeploymentTree_getNumberOfCTDefContainer(self)

    def getNumberOfRTODefContainer(self):
        """getNumberOfRTODefContainer(self) -> unsigned int"""
        return _pilot.DeploymentTree_getNumberOfRTODefContainer(self)

    def getNumberOfCTDefComponentInstances(self):
        """getNumberOfCTDefComponentInstances(self) -> unsigned int"""
        return _pilot.DeploymentTree_getNumberOfCTDefComponentInstances(self)

    def getNumberOfRTODefComponentInstances(self):
        """getNumberOfRTODefComponentInstances(self) -> unsigned int"""
        return _pilot.DeploymentTree_getNumberOfRTODefComponentInstances(self)

    def presenceOfDefaultContainer(self):
        """presenceOfDefaultContainer(self) -> bool"""
        return _pilot.DeploymentTree_presenceOfDefaultContainer(self)

    def getAllContainers(self):
        """getAllContainers(self) -> std::vector<(p.YACS::ENGINE::Container,std::allocator<(p.YACS::ENGINE::Container)>)>"""
        return _pilot.DeploymentTree_getAllContainers(self)

    def getAllCTDefContainers(self):
        """getAllCTDefContainers(self) -> std::vector<(p.YACS::ENGINE::Container,std::allocator<(p.YACS::ENGINE::Container)>)>"""
        return _pilot.DeploymentTree_getAllCTDefContainers(self)

    def getAllRTODefContainers(self):
        """getAllRTODefContainers(self) -> std::vector<(p.YACS::ENGINE::Container,std::allocator<(p.YACS::ENGINE::Container)>)>"""
        return _pilot.DeploymentTree_getAllRTODefContainers(self)

    def getTasksLinkedToComponent(self, *args):
        """getTasksLinkedToComponent(self, ComponentInstance comp) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.DeploymentTree_getTasksLinkedToComponent(self, *args)

    def getTasksLinkedToContainer(self, *args):
        """getTasksLinkedToContainer(self, Container cont) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.DeploymentTree_getTasksLinkedToContainer(self, *args)

    def getComponentsLinkedToContainer(self, *args):
        """getComponentsLinkedToContainer(self, Container cont) -> std::vector<(p.YACS::ENGINE::ComponentInstance,std::allocator<(p.YACS::ENGINE::ComponentInstance)>)>"""
        return _pilot.DeploymentTree_getComponentsLinkedToContainer(self, *args)

    def isNull(self):
        """isNull(self) -> bool"""
        return _pilot.DeploymentTree_isNull(self)

    def getFreeDeployableTasks(self):
        """getFreeDeployableTasks(self) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.DeploymentTree_getFreeDeployableTasks(self)

    NULL_TASK = _pilot.DeploymentTree_NULL_TASK
    APPEND_OK = _pilot.DeploymentTree_APPEND_OK
    NULL_TREE = _pilot.DeploymentTree_NULL_TREE
    ALREADY_IN_TREE = _pilot.DeploymentTree_ALREADY_IN_TREE
    NOT_DEPLOYABLE_TASK = _pilot.DeploymentTree_NOT_DEPLOYABLE_TASK
    DEPLOYABLE_BUT_NOT_SPECIFIED = _pilot.DeploymentTree_DEPLOYABLE_BUT_NOT_SPECIFIED
    DUP_TASK_NOT_COMPATIBLE_WITH_EXISTING_TREE = _pilot.DeploymentTree_DUP_TASK_NOT_COMPATIBLE_WITH_EXISTING_TREE
DeploymentTree_swigregister = _pilot.DeploymentTree_swigregister
DeploymentTree_swigregister(DeploymentTree)

class Port(_object):
    """Proxy of C++ YACS::ENGINE::Port class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Port, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Port, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_Port
    __del__ = lambda self : None;
    def getNode(self):
        """getNode(self) -> Node"""
        return _pilot.Port_getNode(self)

    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.Port_getNameOfTypeOfCurrentInstance(self)

    def getNumId(self):
        """getNumId(self) -> int"""
        return _pilot.Port_getNumId(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.Port_typeName(self)

    def modified(self):
        """modified(self)"""
        return _pilot.Port_modified(self)

    def __cmp__(self, *args):
        """__cmp__(self, Port other) -> int"""
        return _pilot.Port___cmp__(self, *args)

    def ptr(self):
        """ptr(self) -> long"""
        return _pilot.Port_ptr(self)

Port_swigregister = _pilot.Port_swigregister
Port_swigregister(Port)

DATAFLOW = _pilot.DATAFLOW
DATASTREAM = _pilot.DATASTREAM
class DataPort(Port):
    """Proxy of C++ YACS::ENGINE::DataPort class"""
    __swig_setmethods__ = {}
    for _s in [Port]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataPort, name, value)
    __swig_getmethods__ = {}
    for _s in [Port]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def edGetType(self):
        """edGetType(self) -> TypeCode"""
        return _pilot.DataPort_edGetType(self)

    def edSetType(self, *args):
        """edSetType(self, TypeCode type)"""
        return _pilot.DataPort_edSetType(self, *args)

    def getName(self):
        """getName(self) -> string"""
        return _pilot.DataPort_getName(self)

    def setName(self, *args):
        """setName(self, string theName)"""
        return _pilot.DataPort_setName(self, *args)

    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.DataPort_getNameOfTypeOfCurrentInstance(self)

    def getTypeOfChannel(self):
        """getTypeOfChannel(self) -> TypeOfChannel"""
        return _pilot.DataPort_getTypeOfChannel(self)

    def isDifferentTypeOf(self, *args):
        """isDifferentTypeOf(self, DataPort other) -> bool"""
        return _pilot.DataPort_isDifferentTypeOf(self, *args)

    def edRemoveAllLinksLinkedWithMe(self):
        """edRemoveAllLinksLinkedWithMe(self)"""
        return _pilot.DataPort_edRemoveAllLinksLinkedWithMe(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.DataPort_typeName(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _pilot.DataPort_getAsString(self)

    def isCrossingType(*args):
        """isCrossingType(std::vector<(p.YACS::ENGINE::DataPort,std::allocator<(p.YACS::ENGINE::DataPort)>)> historyOfLink) -> DataPort"""
        return _pilot.DataPort_isCrossingType(*args)

    if _newclass:isCrossingType = staticmethod(isCrossingType)
    __swig_getmethods__["isCrossingType"] = lambda x: isCrossingType
DataPort_swigregister = _pilot.DataPort_swigregister
DataPort_swigregister(DataPort)
DataPort.NAME = _pilot.cvar.DataPort_NAME

def DataPort_isCrossingType(*args):
  """DataPort_isCrossingType(std::vector<(p.YACS::ENGINE::DataPort,std::allocator<(p.YACS::ENGINE::DataPort)>)> historyOfLink) -> DataPort"""
  return _pilot.DataPort_isCrossingType(*args)

class InPort(DataPort):
    """Proxy of C++ YACS::ENGINE::InPort class"""
    __swig_setmethods__ = {}
    for _s in [DataPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getPublicRepresentant(self):
        """getPublicRepresentant(self) -> InPort"""
        return _pilot.InPort_getPublicRepresentant(self)

    def edGetNumberOfLinks(self):
        """edGetNumberOfLinks(self) -> int"""
        return _pilot.InPort_edGetNumberOfLinks(self)

    def edSetOutPort(self):
        """edSetOutPort(self) -> std::set<(p.YACS::ENGINE::OutPort,std::less<(p.YACS::ENGINE::OutPort)>,std::allocator<(p.YACS::ENGINE::OutPort)>)>"""
        return _pilot.InPort_edSetOutPort(self)

    __swig_destroy__ = _pilot.delete_InPort
    __del__ = lambda self : None;
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.InPort_typeName(self)

InPort_swigregister = _pilot.InPort_swigregister
InPort_swigregister(InPort)

class OutPort(DataPort):
    """Proxy of C++ YACS::ENGINE::OutPort class"""
    __swig_setmethods__ = {}
    for _s in [DataPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def checkConsistency(self, *args):
        """checkConsistency(self, LinkInfo info)"""
        return _pilot.OutPort_checkConsistency(self, *args)

    def edGetNumberOfOutLinks(self):
        """edGetNumberOfOutLinks(self) -> int"""
        return _pilot.OutPort_edGetNumberOfOutLinks(self)

    def edSetInPort(self):
        """edSetInPort(self) -> std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)>"""
        return _pilot.OutPort_edSetInPort(self)

    def isAlreadyLinkedWith(self, *args):
        """isAlreadyLinkedWith(self, InPort with) -> bool"""
        return _pilot.OutPort_isAlreadyLinkedWith(self, *args)

    def getAllRepresented(self, *args):
        """getAllRepresented(self, std::set<(p.YACS::ENGINE::OutPort,std::less<(p.YACS::ENGINE::OutPort)>,std::allocator<(p.YACS::ENGINE::OutPort)>)> represented)"""
        return _pilot.OutPort_getAllRepresented(self, *args)

    def addInPort(self, *args):
        """addInPort(self, InPort inPort) -> bool"""
        return _pilot.OutPort_addInPort(self, *args)

    def removeInPort(self, *args):
        """removeInPort(self, InPort inPort, bool forward) -> int"""
        return _pilot.OutPort_removeInPort(self, *args)

    __swig_destroy__ = _pilot.delete_OutPort
    __del__ = lambda self : None;
    def calculateHistoryOfLinkWith(self, *args):
        """calculateHistoryOfLinkWith(self, InPort end) -> std::vector<(p.YACS::ENGINE::DataPort,std::allocator<(p.YACS::ENGINE::DataPort)>)>"""
        return _pilot.OutPort_calculateHistoryOfLinkWith(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.OutPort_typeName(self)

OutPort_swigregister = _pilot.OutPort_swigregister
OutPort_swigregister(OutPort)

class InGate(Port):
    """Proxy of C++ YACS::ENGINE::InGate class"""
    __swig_setmethods__ = {}
    for _s in [Port]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InGate, name, value)
    __swig_getmethods__ = {}
    for _s in [Port]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InGate, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Node node) -> InGate"""
        this = _pilot.new_InGate(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_InGate
    __del__ = lambda self : None;
    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.InGate_getNameOfTypeOfCurrentInstance(self)

    def exNotifyFromPrecursor(self, *args):
        """exNotifyFromPrecursor(self, OutGate fromgate)"""
        return _pilot.InGate_exNotifyFromPrecursor(self, *args)

    def edMapOutGate(self):
        """edMapOutGate(self) -> std::map<(p.YACS::ENGINE::OutGate,bool,std::less<(p.YACS::ENGINE::OutGate)>,std::allocator<(std::pair<(q(const).p.YACS::ENGINE::OutGate,bool)>)>)>"""
        return _pilot.InGate_edMapOutGate(self)

    def edAppendPrecursor(self, *args):
        """edAppendPrecursor(self, OutGate fromgate)"""
        return _pilot.InGate_edAppendPrecursor(self, *args)

    def edRemovePrecursor(self, *args):
        """edRemovePrecursor(self, OutGate fromgate)"""
        return _pilot.InGate_edRemovePrecursor(self, *args)

    def getNumberOfBackLinks(self):
        """getNumberOfBackLinks(self) -> int"""
        return _pilot.InGate_getNumberOfBackLinks(self)

    def edDisconnectAllLinksToMe(self):
        """edDisconnectAllLinksToMe(self)"""
        return _pilot.InGate_edDisconnectAllLinksToMe(self)

    def exNotifyFailed(self):
        """exNotifyFailed(self)"""
        return _pilot.InGate_exNotifyFailed(self)

    def exNotifyDisabled(self):
        """exNotifyDisabled(self)"""
        return _pilot.InGate_exNotifyDisabled(self)

    def exReset(self):
        """exReset(self)"""
        return _pilot.InGate_exReset(self)

    def exIsReady(self):
        """exIsReady(self) -> bool"""
        return _pilot.InGate_exIsReady(self)

    def getBackLinks(self):
        """getBackLinks(self) -> std::list<(p.YACS::ENGINE::OutGate,std::allocator<(p.YACS::ENGINE::OutGate)>)>"""
        return _pilot.InGate_getBackLinks(self)

    def setPrecursorDone(self, *args):
        """setPrecursorDone(self, OutGate fromgate)"""
        return _pilot.InGate_setPrecursorDone(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.InGate_typeName(self)

InGate_swigregister = _pilot.InGate_swigregister
InGate_swigregister(InGate)

class OutGate(Port):
    """Proxy of C++ YACS::ENGINE::OutGate class"""
    __swig_setmethods__ = {}
    for _s in [Port]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutGate, name, value)
    __swig_getmethods__ = {}
    for _s in [Port]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutGate, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Node node) -> OutGate"""
        this = _pilot.new_OutGate(*args)
        try: self.this.append(this)
        except: self.this = this
    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.OutGate_getNameOfTypeOfCurrentInstance(self)

    def exReset(self):
        """exReset(self)"""
        return _pilot.OutGate_exReset(self)

    def exNotifyDone(self):
        """exNotifyDone(self)"""
        return _pilot.OutGate_exNotifyDone(self)

    def exNotifyFailed(self):
        """exNotifyFailed(self)"""
        return _pilot.OutGate_exNotifyFailed(self)

    def exNotifyDisabled(self):
        """exNotifyDisabled(self)"""
        return _pilot.OutGate_exNotifyDisabled(self)

    def edDisconnectAllLinksFromMe(self):
        """edDisconnectAllLinksFromMe(self)"""
        return _pilot.OutGate_edDisconnectAllLinksFromMe(self)

    def edAddInGate(self, *args):
        """edAddInGate(self, InGate inGate) -> bool"""
        return _pilot.OutGate_edAddInGate(self, *args)

    def edMapInGate(self):
        """edMapInGate(self) -> std::map<(p.YACS::ENGINE::InGate,bool,std::less<(p.YACS::ENGINE::InGate)>,std::allocator<(std::pair<(q(const).p.YACS::ENGINE::InGate,bool)>)>)>"""
        return _pilot.OutGate_edMapInGate(self)

    def edSetInGate(self):
        """edSetInGate(self) -> std::set<(p.YACS::ENGINE::InGate,std::less<(p.YACS::ENGINE::InGate)>,std::allocator<(p.YACS::ENGINE::InGate)>)>"""
        return _pilot.OutGate_edSetInGate(self)

    def edRemoveInGate(self, *args):
        """
        edRemoveInGate(self, InGate inGate, bool coherenceWithInGate = True)
        edRemoveInGate(self, InGate inGate)
        """
        return _pilot.OutGate_edRemoveInGate(self, *args)

    def getNbOfInGatesConnected(self):
        """getNbOfInGatesConnected(self) -> int"""
        return _pilot.OutGate_getNbOfInGatesConnected(self)

    def isAlreadyInSet(self, *args):
        """isAlreadyInSet(self, InGate inGate) -> bool"""
        return _pilot.OutGate_isAlreadyInSet(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.OutGate_typeName(self)

    __swig_destroy__ = _pilot.delete_OutGate
    __del__ = lambda self : None;
OutGate_swigregister = _pilot.OutGate_swigregister
OutGate_swigregister(OutGate)
OutGate.NAME = _pilot.cvar.OutGate_NAME

class DataFlowPort(DataPort):
    """Proxy of C++ YACS::ENGINE::DataFlowPort class"""
    __swig_setmethods__ = {}
    for _s in [DataPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataFlowPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataFlowPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.DataFlowPort_getNameOfTypeOfCurrentInstance(self)

    def getTypeOfChannel(self):
        """getTypeOfChannel(self) -> TypeOfChannel"""
        return _pilot.DataFlowPort_getTypeOfChannel(self)

    __swig_destroy__ = _pilot.delete_DataFlowPort
    __del__ = lambda self : None;
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.DataFlowPort_typeName(self)

    def valToStr(self):
        """valToStr(self) -> string"""
        return _pilot.DataFlowPort_valToStr(self)

    def valFromStr(self, *args):
        """valFromStr(self, string valstr)"""
        return _pilot.DataFlowPort_valFromStr(self, *args)

DataFlowPort_swigregister = _pilot.DataFlowPort_swigregister
DataFlowPort_swigregister(DataFlowPort)
DataFlowPort.NAME = _pilot.cvar.DataFlowPort_NAME

class DataStreamPort(DataPort):
    """Proxy of C++ YACS::ENGINE::DataStreamPort class"""
    __swig_setmethods__ = {}
    for _s in [DataPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataStreamPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataStreamPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.DataStreamPort_getNameOfTypeOfCurrentInstance(self)

    def getTypeOfChannel(self):
        """getTypeOfChannel(self) -> TypeOfChannel"""
        return _pilot.DataStreamPort_getTypeOfChannel(self)

    def setProperty(self, *args):
        """setProperty(self, string name, string value)"""
        return _pilot.DataStreamPort_setProperty(self, *args)

    def setProperties(self, *args):
        """setProperties(self, propmap properties)"""
        return _pilot.DataStreamPort_setProperties(self, *args)

    def getProperty(self, *args):
        """getProperty(self, string name) -> string"""
        return _pilot.DataStreamPort_getProperty(self, *args)

    def getProperties(self):
        """getProperties(self) -> propmap"""
        return _pilot.DataStreamPort_getProperties(self)

    def initPortProperties(self):
        """initPortProperties(self)"""
        return _pilot.DataStreamPort_initPortProperties(self)

    __swig_destroy__ = _pilot.delete_DataStreamPort
    __del__ = lambda self : None;
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.DataStreamPort_typeName(self)

DataStreamPort_swigregister = _pilot.DataStreamPort_swigregister
DataStreamPort_swigregister(DataStreamPort)
DataStreamPort.NAME = _pilot.cvar.DataStreamPort_NAME

I_CF_USELESS = _pilot.I_CF_USELESS
I_USELESS = _pilot.I_USELESS
I_BACK = _pilot.I_BACK
I_BACK_USELESS = _pilot.I_BACK_USELESS
I_BACK_CRAZY = _pilot.I_BACK_CRAZY
I_DFDS = _pilot.I_DFDS
I_ALL = _pilot.I_ALL
W_COLLAPSE = _pilot.W_COLLAPSE
W_COLLAPSE_AND_USELESS = _pilot.W_COLLAPSE_AND_USELESS
W_COLLAPSE_EL = _pilot.W_COLLAPSE_EL
W_COLLAPSE_EL_AND_USELESS = _pilot.W_COLLAPSE_EL_AND_USELESS
W_BACK_COLLAPSE = _pilot.W_BACK_COLLAPSE
W_BACK_COLLAPSE_AND_USELESS = _pilot.W_BACK_COLLAPSE_AND_USELESS
W_BACK_COLLAPSE_EL = _pilot.W_BACK_COLLAPSE_EL
W_BACK_COLLAPSE_EL_AND_USELESS = _pilot.W_BACK_COLLAPSE_EL_AND_USELESS
W_ALL = _pilot.W_ALL
E_NEVER_SET_INPUTPORT = _pilot.E_NEVER_SET_INPUTPORT
E_ONLY_BACKWARD_DEFINED = _pilot.E_ONLY_BACKWARD_DEFINED
E_DS_LINK_UNESTABLISHABLE = _pilot.E_DS_LINK_UNESTABLISHABLE
E_COLLAPSE_DFDS = _pilot.E_COLLAPSE_DFDS
E_COLLAPSE_DS = _pilot.E_COLLAPSE_DS
E_UNPREDICTABLE_FED = _pilot.E_UNPREDICTABLE_FED
E_UNCOMPLETE_SW = _pilot.E_UNCOMPLETE_SW
E_ALL = _pilot.E_ALL
class LinkInfo(_object):
    """Proxy of C++ YACS::ENGINE::LinkInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinkInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinkInfo, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, unsigned char level) -> LinkInfo"""
        this = _pilot.new_LinkInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    def clearAll(self):
        """clearAll(self)"""
        return _pilot.LinkInfo_clearAll(self)

    def startCollapseTransac(self):
        """startCollapseTransac(self)"""
        return _pilot.LinkInfo_startCollapseTransac(self)

    def endCollapseTransac(self):
        """endCollapseTransac(self)"""
        return _pilot.LinkInfo_endCollapseTransac(self)

    def setPointOfView(self, *args):
        """setPointOfView(self, ComposedNode pov)"""
        return _pilot.LinkInfo_setPointOfView(self, *args)

    def pushInfoLink(self, *args):
        """pushInfoLink(self, OutPort semStart, InPort end, InfoReason reason)"""
        return _pilot.LinkInfo_pushInfoLink(self, *args)

    def pushWarnLink(self, *args):
        """pushWarnLink(self, OutPort semStart, InPort end, WarnReason reason)"""
        return _pilot.LinkInfo_pushWarnLink(self, *args)

    def pushErrLink(self, *args):
        """pushErrLink(self, OutPort semStart, InPort end, ErrReason reason)"""
        return _pilot.LinkInfo_pushErrLink(self, *args)

    def pushErrSwitch(self, *args):
        """pushErrSwitch(self, CollectorSwOutPort collector)"""
        return _pilot.LinkInfo_pushErrSwitch(self, *args)

    def pushUselessCFLink(self, *args):
        """pushUselessCFLink(self, Node start, Node end)"""
        return _pilot.LinkInfo_pushUselessCFLink(self, *args)

    def takeDecision(self):
        """takeDecision(self)"""
        return _pilot.LinkInfo_takeDecision(self)

    def getGlobalRepr(self):
        """getGlobalRepr(self) -> string"""
        return _pilot.LinkInfo_getGlobalRepr(self)

    def getInfoRepr(self):
        """getInfoRepr(self) -> string"""
        return _pilot.LinkInfo_getInfoRepr(self)

    def getWarnRepr(self):
        """getWarnRepr(self) -> string"""
        return _pilot.LinkInfo_getWarnRepr(self)

    def getErrRepr(self):
        """getErrRepr(self) -> string"""
        return _pilot.LinkInfo_getErrRepr(self)

    def areWarningsOrErrors(self):
        """areWarningsOrErrors(self) -> bool"""
        return _pilot.LinkInfo_areWarningsOrErrors(self)

    def getNumberOfInfoLinks(self, *args):
        """getNumberOfInfoLinks(self, InfoReason reason) -> unsigned int"""
        return _pilot.LinkInfo_getNumberOfInfoLinks(self, *args)

    def getNumberOfWarnLinksGrp(self, *args):
        """getNumberOfWarnLinksGrp(self, WarnReason reason) -> unsigned int"""
        return _pilot.LinkInfo_getNumberOfWarnLinksGrp(self, *args)

    def getNumberOfErrLinks(self, *args):
        """getNumberOfErrLinks(self, ErrReason reason) -> unsigned int"""
        return _pilot.LinkInfo_getNumberOfErrLinks(self, *args)

    def getInfoUselessLinks(self):
        """getInfoUselessLinks(self) -> std::set<(std::pair<(p.YACS::ENGINE::Node,p.YACS::ENGINE::Node)>,std::less<(std::pair<(p.YACS::ENGINE::Node,p.YACS::ENGINE::Node)>)>,std::allocator<(std::pair<(p.YACS::ENGINE::Node,p.YACS::ENGINE::Node)>)>)>"""
        return _pilot.LinkInfo_getInfoUselessLinks(self)

    def getInfoLink(self, *args):
        """getInfoLink(self, unsigned int id, InfoReason reason) -> __dummy_7__"""
        return _pilot.LinkInfo_getInfoLink(self, *args)

    def getWarnLink(self, *args):
        """getWarnLink(self, unsigned int id, WarnReason reason) -> linksvec"""
        return _pilot.LinkInfo_getWarnLink(self, *args)

    def getErrLink(self, *args):
        """getErrLink(self, unsigned int id, ErrReason reason) -> __dummy_7__"""
        return _pilot.LinkInfo_getErrLink(self, *args)

    ALL_STOP_ASAP = _pilot.LinkInfo_ALL_STOP_ASAP
    ALL_DONT_STOP = _pilot.LinkInfo_ALL_DONT_STOP
    WARN_ONLY_DONT_STOP = _pilot.LinkInfo_WARN_ONLY_DONT_STOP
    __swig_destroy__ = _pilot.delete_LinkInfo
    __del__ = lambda self : None;
LinkInfo_swigregister = _pilot.LinkInfo_swigregister
LinkInfo_swigregister(LinkInfo)

class Logger(_object):
    """Proxy of C++ YACS::ENGINE::Logger class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Logger, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Logger, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string name) -> Logger"""
        this = _pilot.new_Logger(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_Logger
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _pilot.Logger_getName(self)

    def log(self, *args):
        """log(self, int level, string message, char filename, int line)"""
        return _pilot.Logger_log(self, *args)

    def error(self, *args):
        """error(self, string message, char filename, int line)"""
        return _pilot.Logger_error(self, *args)

    def fatal(self, *args):
        """fatal(self, string message, char filename, int line)"""
        return _pilot.Logger_fatal(self, *args)

    def warning(self, *args):
        """warning(self, string message, char filename, int line)"""
        return _pilot.Logger_warning(self, *args)

    def makeRecord(self, *args):
        """
        makeRecord(self, string name, int level, string message, char filename, 
            int line) -> LogRecord
        """
        return _pilot.Logger_makeRecord(self, *args)

    def handle(self, *args):
        """handle(self, LogRecord record)"""
        return _pilot.Logger_handle(self, *args)

    def reset(self):
        """reset(self)"""
        return _pilot.Logger_reset(self)

    def getStr(self):
        """getStr(self) -> string"""
        return _pilot.Logger_getStr(self)

    def isEmpty(self):
        """isEmpty(self) -> bool"""
        return _pilot.Logger_isEmpty(self)

    def hasErrors(self):
        """hasErrors(self) -> bool"""
        return _pilot.Logger_hasErrors(self)

Logger_swigregister = _pilot.Logger_swigregister
Logger_swigregister(Logger)

class ComponentInstance(PropertyInterface,RefCounter):
    """Proxy of C++ YACS::ENGINE::ComponentInstance class"""
    __swig_setmethods__ = {}
    for _s in [PropertyInterface,RefCounter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComponentInstance, name, value)
    __swig_getmethods__ = {}
    for _s in [PropertyInterface,RefCounter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComponentInstance, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getCompoName(self):
        """getCompoName(self) -> string"""
        return _pilot.ComponentInstance_getCompoName(self)

    def getInstanceName(self):
        """getInstanceName(self) -> string"""
        return _pilot.ComponentInstance_getInstanceName(self)

    def setName(self, *args):
        """setName(self, string name)"""
        return _pilot.ComponentInstance_setName(self, *args)

    def setAnonymous(self, *args):
        """setAnonymous(self, bool anon)"""
        return _pilot.ComponentInstance_setAnonymous(self, *args)

    def isAnonymous(self):
        """isAnonymous(self) -> bool"""
        return _pilot.ComponentInstance_isAnonymous(self)

    def getNumId(self):
        """getNumId(self) -> int"""
        return _pilot.ComponentInstance_getNumId(self)

    def setContainer(self, *args):
        """setContainer(self, Container cont)"""
        return _pilot.ComponentInstance_setContainer(self, *args)

    def getContainer(self):
        """getContainer(self) -> Container"""
        return _pilot.ComponentInstance_getContainer(self)

    def load(self):
        """load(self)"""
        return _pilot.ComponentInstance_load(self)

    def unload(self):
        """unload(self)"""
        return _pilot.ComponentInstance_unload(self)

    def isLoaded(self):
        """isLoaded(self) -> bool"""
        return _pilot.ComponentInstance_isLoaded(self)

    def attachOnCloning(self):
        """attachOnCloning(self)"""
        return _pilot.ComponentInstance_attachOnCloning(self)

    def dettachOnCloning(self):
        """dettachOnCloning(self)"""
        return _pilot.ComponentInstance_dettachOnCloning(self)

    def isAttachedOnCloning(self):
        """isAttachedOnCloning(self) -> bool"""
        return _pilot.ComponentInstance_isAttachedOnCloning(self)

    def getFileRepr(self):
        """getFileRepr(self) -> string"""
        return _pilot.ComponentInstance_getFileRepr(self)

    def createNode(self, *args):
        """createNode(self, string name) -> ServiceNode"""
        return _pilot.ComponentInstance_createNode(self, *args)

    def clone(self):
        """clone(self) -> ComponentInstance"""
        return _pilot.ComponentInstance_clone(self)

    def getKind(self):
        """getKind(self) -> string"""
        return _pilot.ComponentInstance_getKind(self)

ComponentInstance_swigregister = _pilot.ComponentInstance_swigregister
ComponentInstance_swigregister(ComponentInstance)
ComponentInstance.KIND = _pilot.cvar.ComponentInstance_KIND

class Container(RefCounter):
    """Proxy of C++ YACS::ENGINE::Container class"""
    __swig_setmethods__ = {}
    for _s in [RefCounter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Container, name, value)
    __swig_getmethods__ = {}
    for _s in [RefCounter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Container, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def isAlreadyStarted(self, *args):
        """isAlreadyStarted(self, ComponentInstance inst) -> bool"""
        return _pilot.Container_isAlreadyStarted(self, *args)

    def start(self, *args):
        """start(self, ComponentInstance inst)"""
        return _pilot.Container_start(self, *args)

    def getPlacementId(self, *args):
        """getPlacementId(self, ComponentInstance inst) -> string"""
        return _pilot.Container_getPlacementId(self, *args)

    def attachOnCloning(self):
        """attachOnCloning(self)"""
        return _pilot.Container_attachOnCloning(self)

    def dettachOnCloning(self):
        """dettachOnCloning(self)"""
        return _pilot.Container_dettachOnCloning(self)

    def isAttachedOnCloning(self):
        """isAttachedOnCloning(self) -> bool"""
        return _pilot.Container_isAttachedOnCloning(self)

    def clone(self):
        """clone(self) -> Container"""
        return _pilot.Container_clone(self)

    def isSupportingRTODefNbOfComp(self):
        """isSupportingRTODefNbOfComp(self) -> bool"""
        return _pilot.Container_isSupportingRTODefNbOfComp(self)

    def checkCapabilityToDealWith(self, *args):
        """checkCapabilityToDealWith(self, ComponentInstance inst)"""
        return _pilot.Container_checkCapabilityToDealWith(self, *args)

    def setProperty(self, *args):
        """setProperty(self, string name, string value)"""
        return _pilot.Container_setProperty(self, *args)

    def getProperty(self, *args):
        """getProperty(self, string name) -> string"""
        return _pilot.Container_getProperty(self, *args)

    def getProperties(self):
        """getProperties(self) -> propmap"""
        return _pilot.Container_getProperties(self)

    def setProperties(self, *args):
        """setProperties(self, propmap properties)"""
        return _pilot.Container_setProperties(self, *args)

    def getName(self):
        """getName(self) -> string"""
        return _pilot.Container_getName(self)

    def setName(self, *args):
        """setName(self, string name)"""
        return _pilot.Container_setName(self, *args)

    def setProc(self, *args):
        """setProc(self, Proc proc)"""
        return _pilot.Container_setProc(self, *args)

    def getProc(self):
        """getProc(self) -> Proc"""
        return _pilot.Container_getProc(self)

    __swig_destroy__ = _pilot.delete_Container
    __del__ = lambda self : None;
Container_swigregister = _pilot.Container_swigregister
Container_swigregister(Container)

class InputPort(DataFlowPort,InPort):
    """Proxy of C++ YACS::ENGINE::InputPort class"""
    __swig_setmethods__ = {}
    for _s in [DataFlowPort,InPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataFlowPort,InPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_InputPort
    __del__ = lambda self : None;
    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.InputPort_getNameOfTypeOfCurrentInstance(self)

    def getPublicRepresentant(self):
        """getPublicRepresentant(self) -> InputPort"""
        return _pilot.InputPort_getPublicRepresentant(self)

    def isIntermediate(self):
        """isIntermediate(self) -> bool"""
        return _pilot.InputPort_isIntermediate(self)

    def edIsManuallyInitialized(self):
        """edIsManuallyInitialized(self) -> bool"""
        return _pilot.InputPort_edIsManuallyInitialized(self)

    def edIsInitialized(self):
        """edIsInitialized(self) -> bool"""
        return _pilot.InputPort_edIsInitialized(self)

    def edInit(self, *args):
        """
        edInit(self, Any value)
        edInit(self, string impl, void value)
        """
        return _pilot.InputPort_edInit(self, *args)

    def edRemoveManInit(self):
        """edRemoveManInit(self)"""
        return _pilot.InputPort_edRemoveManInit(self)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.InputPort_checkBasicConsistency(self)

    def exInit(self, *args):
        """exInit(self, bool start)"""
        return _pilot.InputPort_exInit(self, *args)

    def exSaveInit(self):
        """exSaveInit(self)"""
        return _pilot.InputPort_exSaveInit(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _pilot.InputPort_exRestoreInit(self)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _pilot.InputPort_clone(self, *args)

    def isEmpty(self):
        """isEmpty(self) -> bool"""
        return _pilot.InputPort_isEmpty(self)

    def get(self):
        """get(self) -> void"""
        return _pilot.InputPort_get(self)

    def put(self, *args):
        """put(self, void data)"""
        return _pilot.InputPort_put(self, *args)

    def dump(self):
        """dump(self) -> string"""
        return _pilot.InputPort_dump(self)

    def setStringRef(self, *args):
        """setStringRef(self, string strRef)"""
        return _pilot.InputPort_setStringRef(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.InputPort_typeName(self)

    def edInitXML(self, *args):
        """edInitXML(self, char s)"""
        return _pilot.InputPort_edInitXML(self, *args)

    def edInitPy(self, *args):
        """edInitPy(self, PyObject ob)"""
        return _pilot.InputPort_edInitPy(self, *args)

    def edInitInt(self, *args):
        """edInitInt(self, int value)"""
        return _pilot.InputPort_edInitInt(self, *args)

    def edInitBool(self, *args):
        """edInitBool(self, bool value)"""
        return _pilot.InputPort_edInitBool(self, *args)

    def edInitString(self, *args):
        """edInitString(self, string value)"""
        return _pilot.InputPort_edInitString(self, *args)

    def edInitDbl(self, *args):
        """edInitDbl(self, double value)"""
        return _pilot.InputPort_edInitDbl(self, *args)

InputPort_swigregister = _pilot.InputPort_swigregister
InputPort_swigregister(InputPort)
InputPort.NAME = _pilot.cvar.InputPort_NAME

class ProxyPort(InputPort):
    """Proxy of C++ YACS::ENGINE::ProxyPort class"""
    __swig_setmethods__ = {}
    for _s in [InputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProxyPort, name, value)
    __swig_getmethods__ = {}
    for _s in [InputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ProxyPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, InputPort p) -> ProxyPort"""
        this = _pilot.new_ProxyPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_ProxyPort
    __del__ = lambda self : None;
    def edRemoveAllLinksLinkedWithMe(self):
        """edRemoveAllLinksLinkedWithMe(self)"""
        return _pilot.ProxyPort_edRemoveAllLinksLinkedWithMe(self)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _pilot.ProxyPort_clone(self, *args)

    def edNotifyReferencedBy(self, *args):
        """edNotifyReferencedBy(self, OutPort fromPort)"""
        return _pilot.ProxyPort_edNotifyReferencedBy(self, *args)

    def edNotifyDereferencedBy(self, *args):
        """edNotifyDereferencedBy(self, OutPort fromPort)"""
        return _pilot.ProxyPort_edNotifyDereferencedBy(self, *args)

    def edSetOutPort(self):
        """edSetOutPort(self) -> std::set<(p.YACS::ENGINE::OutPort,std::less<(p.YACS::ENGINE::OutPort)>,std::allocator<(p.YACS::ENGINE::OutPort)>)>"""
        return _pilot.ProxyPort_edSetOutPort(self)

    def getPublicRepresentant(self):
        """getPublicRepresentant(self) -> InputPort"""
        return _pilot.ProxyPort_getPublicRepresentant(self)

    def get(self):
        """get(self) -> void"""
        return _pilot.ProxyPort_get(self)

    def put(self, *args):
        """put(self, void data)"""
        return _pilot.ProxyPort_put(self, *args)

    def edGetNumberOfLinks(self):
        """edGetNumberOfLinks(self) -> int"""
        return _pilot.ProxyPort_edGetNumberOfLinks(self)

    def isIntermediate(self):
        """isIntermediate(self) -> bool"""
        return _pilot.ProxyPort_isIntermediate(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _pilot.ProxyPort_exRestoreInit(self)

    def exSaveInit(self):
        """exSaveInit(self)"""
        return _pilot.ProxyPort_exSaveInit(self)

    def getAllRepresentants(self, *args):
        """getAllRepresentants(self, std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)> repr)"""
        return _pilot.ProxyPort_getAllRepresentants(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ProxyPort_typeName(self)

ProxyPort_swigregister = _pilot.ProxyPort_swigregister
ProxyPort_swigregister(ProxyPort)

class AnyInputPort(InputPort):
    """Proxy of C++ YACS::ENGINE::AnyInputPort class"""
    __swig_setmethods__ = {}
    for _s in [InputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnyInputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [InputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnyInputPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> AnyInputPort
        __init__(self, AnyInputPort other, Node newHelder) -> AnyInputPort
        """
        this = _pilot.new_AnyInputPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_AnyInputPort
    __del__ = lambda self : None;
    def exSaveInit(self):
        """exSaveInit(self)"""
        return _pilot.AnyInputPort_exSaveInit(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _pilot.AnyInputPort_exRestoreInit(self)

    def getValue(self):
        """getValue(self) -> Any"""
        return _pilot.AnyInputPort_getValue(self)

    def getIntValue(self):
        """getIntValue(self) -> int"""
        return _pilot.AnyInputPort_getIntValue(self)

    def get(self):
        """get(self) -> void"""
        return _pilot.AnyInputPort_get(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _pilot.AnyInputPort_getAsString(self)

    def isEmpty(self):
        """isEmpty(self) -> bool"""
        return _pilot.AnyInputPort_isEmpty(self)

    def put(self, *args):
        """
        put(self, Any data)
        put(self, void data)
        """
        return _pilot.AnyInputPort_put(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _pilot.AnyInputPort_clone(self, *args)

    def dump(self):
        """dump(self) -> string"""
        return _pilot.AnyInputPort_dump(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.AnyInputPort_typeName(self)

    def getPyObj(self):
        """getPyObj(self) -> PyObject"""
        return _pilot.AnyInputPort_getPyObj(self)

AnyInputPort_swigregister = _pilot.AnyInputPort_swigregister
AnyInputPort_swigregister(AnyInputPort)

class ConditionInputPort(InputPort):
    """Proxy of C++ YACS::ENGINE::ConditionInputPort class"""
    __swig_setmethods__ = {}
    for _s in [InputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ConditionInputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [InputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ConditionInputPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def exSaveInit(self):
        """exSaveInit(self)"""
        return _pilot.ConditionInputPort_exSaveInit(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _pilot.ConditionInputPort_exRestoreInit(self)

    def isLinkedOutOfScope(self):
        """isLinkedOutOfScope(self) -> bool"""
        return _pilot.ConditionInputPort_isLinkedOutOfScope(self)

    def edNotifyReferencedBy(self, *args):
        """edNotifyReferencedBy(self, OutPort fromPort)"""
        return _pilot.ConditionInputPort_edNotifyReferencedBy(self, *args)

    def edNotifyDereferencedBy(self, *args):
        """edNotifyDereferencedBy(self, OutPort fromPort)"""
        return _pilot.ConditionInputPort_edNotifyDereferencedBy(self, *args)

    def get(self):
        """get(self) -> void"""
        return _pilot.ConditionInputPort_get(self)

    def put(self, *args):
        """
        put(self, void data)
        put(self, Any data)
        """
        return _pilot.ConditionInputPort_put(self, *args)

    def dump(self):
        """dump(self) -> string"""
        return _pilot.ConditionInputPort_dump(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _pilot.ConditionInputPort_getAsString(self)

    def getValue(self):
        """getValue(self) -> bool"""
        return _pilot.ConditionInputPort_getValue(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ConditionInputPort_typeName(self)

    def getPyObj(self):
        """getPyObj(self) -> bool"""
        return _pilot.ConditionInputPort_getPyObj(self)

ConditionInputPort_swigregister = _pilot.ConditionInputPort_swigregister
ConditionInputPort_swigregister(ConditionInputPort)

class OutputPort(DataFlowPort,OutPort):
    """Proxy of C++ YACS::ENGINE::OutputPort class"""
    __swig_setmethods__ = {}
    for _s in [DataFlowPort,OutPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataFlowPort,OutPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_OutputPort
    __del__ = lambda self : None;
    def edSetInPort(self):
        """edSetInPort(self) -> std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)>"""
        return _pilot.OutputPort_edSetInPort(self)

    def isAlreadyLinkedWith(self, *args):
        """isAlreadyLinkedWith(self, InPort with) -> bool"""
        return _pilot.OutputPort_isAlreadyLinkedWith(self, *args)

    def isAlreadyInSet(self, *args):
        """isAlreadyInSet(self, InputPort inputPort) -> bool"""
        return _pilot.OutputPort_isAlreadyInSet(self, *args)

    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.OutputPort_getNameOfTypeOfCurrentInstance(self)

    def removeInPort(self, *args):
        """removeInPort(self, InPort inPort, bool forward) -> int"""
        return _pilot.OutputPort_removeInPort(self, *args)

    def edAddInputPort(self, *args):
        """edAddInputPort(self, InputPort phyPort) -> bool"""
        return _pilot.OutputPort_edAddInputPort(self, *args)

    def edRemoveInputPort(self, *args):
        """edRemoveInputPort(self, InputPort inputPort, bool forward) -> int"""
        return _pilot.OutputPort_edRemoveInputPort(self, *args)

    def addInPort(self, *args):
        """addInPort(self, InPort inPort) -> bool"""
        return _pilot.OutputPort_addInPort(self, *args)

    def edRemoveAllLinksLinkedWithMe(self):
        """edRemoveAllLinksLinkedWithMe(self)"""
        return _pilot.OutputPort_edRemoveAllLinksLinkedWithMe(self)

    def exInit(self):
        """exInit(self)"""
        return _pilot.OutputPort_exInit(self)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.OutputPort_checkBasicConsistency(self)

    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputPort"""
        return _pilot.OutputPort_clone(self, *args)

    def dump(self):
        """dump(self) -> string"""
        return _pilot.OutputPort_dump(self)

    def put(self, *args):
        """put(self, void data)"""
        return _pilot.OutputPort_put(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.OutputPort_typeName(self)

OutputPort_swigregister = _pilot.OutputPort_swigregister
OutputPort_swigregister(OutputPort)
OutputPort.NAME = _pilot.cvar.OutputPort_NAME

class AnyOutputPort(OutputPort):
    """Proxy of C++ YACS::ENGINE::AnyOutputPort class"""
    __swig_setmethods__ = {}
    for _s in [OutputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnyOutputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [OutputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnyOutputPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> AnyOutputPort
        __init__(self, AnyOutputPort other, Node newHelder) -> AnyOutputPort
        """
        this = _pilot.new_AnyOutputPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_AnyOutputPort
    __del__ = lambda self : None;
    def setValue(self, *args):
        """setValue(self, Any data)"""
        return _pilot.AnyOutputPort_setValue(self, *args)

    def put(self, *args):
        """
        put(self, void data)
        put(self, Any data)
        """
        return _pilot.AnyOutputPort_put(self, *args)

    def getValue(self):
        """getValue(self) -> Any"""
        return _pilot.AnyOutputPort_getValue(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _pilot.AnyOutputPort_getAsString(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.AnyOutputPort_typeName(self)

    def getPyObj(self):
        """getPyObj(self) -> PyObject"""
        return _pilot.AnyOutputPort_getPyObj(self)

AnyOutputPort_swigregister = _pilot.AnyOutputPort_swigregister
AnyOutputPort_swigregister(AnyOutputPort)

class InputDataStreamPort(DataStreamPort,InPort):
    """Proxy of C++ YACS::ENGINE::InputDataStreamPort class"""
    __swig_setmethods__ = {}
    for _s in [DataStreamPort,InPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputDataStreamPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataStreamPort,InPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputDataStreamPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, InputDataStreamPort other, Node newHelder) -> InputDataStreamPort
        __init__(self, string name, Node node, TypeCode type) -> InputDataStreamPort
        """
        this = _pilot.new_InputDataStreamPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_InputDataStreamPort
    __del__ = lambda self : None;
    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.InputDataStreamPort_getNameOfTypeOfCurrentInstance(self)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputDataStreamPort"""
        return _pilot.InputDataStreamPort_clone(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.InputDataStreamPort_typeName(self)

InputDataStreamPort_swigregister = _pilot.InputDataStreamPort_swigregister
InputDataStreamPort_swigregister(InputDataStreamPort)
InputDataStreamPort.NAME = _pilot.cvar.InputDataStreamPort_NAME

class OutputDataStreamPort(DataStreamPort,OutPort):
    """Proxy of C++ YACS::ENGINE::OutputDataStreamPort class"""
    __swig_setmethods__ = {}
    for _s in [DataStreamPort,OutPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputDataStreamPort, name, value)
    __swig_getmethods__ = {}
    for _s in [DataStreamPort,OutPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputDataStreamPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, OutputDataStreamPort other, Node newHelder) -> OutputDataStreamPort
        __init__(self, string name, Node node, TypeCode type) -> OutputDataStreamPort
        """
        this = _pilot.new_OutputDataStreamPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_OutputDataStreamPort
    __del__ = lambda self : None;
    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputDataStreamPort"""
        return _pilot.OutputDataStreamPort_clone(self, *args)

    def edSetInPort(self):
        """edSetInPort(self) -> std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)>"""
        return _pilot.OutputDataStreamPort_edSetInPort(self)

    def isAlreadyLinkedWith(self, *args):
        """isAlreadyLinkedWith(self, InPort with) -> bool"""
        return _pilot.OutputDataStreamPort_isAlreadyLinkedWith(self, *args)

    def getNameOfTypeOfCurrentInstance(self):
        """getNameOfTypeOfCurrentInstance(self) -> string"""
        return _pilot.OutputDataStreamPort_getNameOfTypeOfCurrentInstance(self)

    def addInPort(self, *args):
        """addInPort(self, InPort inPort) -> bool"""
        return _pilot.OutputDataStreamPort_addInPort(self, *args)

    def edAddInputDataStreamPort(self, *args):
        """edAddInputDataStreamPort(self, InputDataStreamPort port) -> bool"""
        return _pilot.OutputDataStreamPort_edAddInputDataStreamPort(self, *args)

    def edRemoveInputDataStreamPort(self, *args):
        """edRemoveInputDataStreamPort(self, InputDataStreamPort inPort, bool forward) -> int"""
        return _pilot.OutputDataStreamPort_edRemoveInputDataStreamPort(self, *args)

    def edRemoveAllLinksLinkedWithMe(self):
        """edRemoveAllLinksLinkedWithMe(self)"""
        return _pilot.OutputDataStreamPort_edRemoveAllLinksLinkedWithMe(self)

    def removeInPort(self, *args):
        """removeInPort(self, InPort inPort, bool forward) -> int"""
        return _pilot.OutputDataStreamPort_removeInPort(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.OutputDataStreamPort_typeName(self)

OutputDataStreamPort_swigregister = _pilot.OutputDataStreamPort_swigregister
OutputDataStreamPort_swigregister(OutputDataStreamPort)
OutputDataStreamPort.NAME = _pilot.cvar.OutputDataStreamPort_NAME


def StateLoader(*args):
  """StateLoader(Node node, StatesForNode state)"""
  return _pilot.StateLoader(*args)
class Node(_object):
    """Proxy of C++ YACS::ENGINE::Node class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Node, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Node, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_setmethods__["_colour"] = _pilot.Node__colour_set
    __swig_getmethods__["_colour"] = _pilot.Node__colour_get
    if _newclass:_colour = _swig_property(_pilot.Node__colour_get, _pilot.Node__colour_set)
    __swig_destroy__ = _pilot.delete_Node
    __del__ = lambda self : None;
    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.Node_init(self, start)

    def shutdown(self):
        """shutdown(self)"""
        return _pilot.Node_shutdown(self)

    def clone(self, *args):
        """
        clone(self, ComposedNode father, bool editionOnly = True) -> Node
        clone(self, ComposedNode father) -> Node
        """
        return _pilot.Node_clone(self, *args)

    def setState(self, *args):
        """setState(self, StatesForNode theState)"""
        return _pilot.Node_setState(self, *args)

    def getState(self):
        """getState(self) -> StatesForNode"""
        return _pilot.Node_getState(self)

    def getEffectiveState(self, *args):
        """
        getEffectiveState(self) -> StatesForNode
        getEffectiveState(self, Node arg0) -> StatesForNode
        """
        return _pilot.Node_getEffectiveState(self, *args)

    def getColorState(self, *args):
        """getColorState(self, StatesForNode state) -> string"""
        return _pilot.Node_getColorState(self, *args)

    def getStateName(*args):
        """getStateName(StatesForNode state) -> string"""
        return _pilot.Node_getStateName(*args)

    if _newclass:getStateName = staticmethod(getStateName)
    __swig_getmethods__["getStateName"] = lambda x: getStateName
    def getInGate(self):
        """getInGate(self) -> InGate"""
        return _pilot.Node_getInGate(self)

    def getOutGate(self):
        """getOutGate(self) -> OutGate"""
        return _pilot.Node_getOutGate(self)

    def getName(self):
        """getName(self) -> string"""
        return _pilot.Node_getName(self)

    def setName(self, *args):
        """setName(self, string name)"""
        return _pilot.Node_setName(self, *args)

    def getFather(self):
        """getFather(self) -> ComposedNode"""
        return _pilot.Node_getFather(self)

    def getId(self):
        """getId(self) -> string"""
        return _pilot.Node_getId(self)

    def exIsControlReady(self):
        """exIsControlReady(self) -> bool"""
        return _pilot.Node_exIsControlReady(self)

    def getOutNodes(self):
        """getOutNodes(self) -> std::set<(p.YACS::ENGINE::Node,std::less<(p.YACS::ENGINE::Node)>,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.Node_getOutNodes(self)

    def writeDot(self, *args):
        """writeDot(self, std::ostream os)"""
        return _pilot.Node_writeDot(self, *args)

    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.Node_exUpdateState(self)

    def exFailedState(self):
        """exFailedState(self)"""
        return _pilot.Node_exFailedState(self)

    def exDisabledState(self):
        """exDisabledState(self)"""
        return _pilot.Node_exDisabledState(self)

    def getReadyTasks(self, *args):
        """getReadyTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Node_getReadyTasks(self, *args)

    def getRecursiveConstituents(self):
        """getRecursiveConstituents(self) -> std::list<(p.YACS::ENGINE::ElementaryNode,std::allocator<(p.YACS::ENGINE::ElementaryNode)>)>"""
        return _pilot.Node_getRecursiveConstituents(self)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.Node_getNumberOfInputPorts(self)

    def getNumberOfOutputPorts(self):
        """getNumberOfOutputPorts(self) -> int"""
        return _pilot.Node_getNumberOfOutputPorts(self)

    def getSetOfInPort(self):
        """getSetOfInPort(self) -> std::list<(p.YACS::ENGINE::InPort,std::allocator<(p.YACS::ENGINE::InPort)>)>"""
        return _pilot.Node_getSetOfInPort(self)

    def getSetOfOutPort(self):
        """getSetOfOutPort(self) -> std::list<(p.YACS::ENGINE::OutPort,std::allocator<(p.YACS::ENGINE::OutPort)>)>"""
        return _pilot.Node_getSetOfOutPort(self)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.Node_getSetOfInputPort(self)

    def getSetOfOutputPort(self):
        """getSetOfOutputPort(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.Node_getSetOfOutputPort(self)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.Node_getLocalInputPorts(self)

    def getLocalOutputPorts(self):
        """getLocalOutputPorts(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.Node_getLocalOutputPorts(self)

    def edGetSetOfUnitializedInputPort(self):
        """edGetSetOfUnitializedInputPort(self) -> std::set<(p.YACS::ENGINE::InputPort,std::less<(p.YACS::ENGINE::InputPort)>,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.Node_edGetSetOfUnitializedInputPort(self)

    def edAreAllInputPortInitialized(self):
        """edAreAllInputPortInitialized(self) -> bool"""
        return _pilot.Node_edAreAllInputPortInitialized(self)

    def getInPortName(self, *args):
        """getInPortName(self, InPort arg0) -> string"""
        return _pilot.Node_getInPortName(self, *args)

    def getOutPortName(self, *args):
        """getOutPortName(self, OutPort arg0) -> string"""
        return _pilot.Node_getOutPortName(self, *args)

    def getSetOfInputDataStreamPort(self):
        """getSetOfInputDataStreamPort(self) -> instreamlist"""
        return _pilot.Node_getSetOfInputDataStreamPort(self)

    def getSetOfOutputDataStreamPort(self):
        """getSetOfOutputDataStreamPort(self) -> outstreamlist"""
        return _pilot.Node_getSetOfOutputDataStreamPort(self)

    def getInPort(self, *args):
        """getInPort(self, string name) -> InPort"""
        return _pilot.Node_getInPort(self, *args)

    def getOutPort(self, *args):
        """getOutPort(self, string name) -> OutPort"""
        return _pilot.Node_getOutPort(self, *args)

    def getAllOutPortsLeavingCurrentScope(self):
        """getAllOutPortsLeavingCurrentScope(self) -> std::set<(p.YACS::ENGINE::OutPort,std::less<(p.YACS::ENGINE::OutPort)>,std::allocator<(p.YACS::ENGINE::OutPort)>)>"""
        return _pilot.Node_getAllOutPortsLeavingCurrentScope(self)

    def getAllInPortsComingFromOutsideOfCurrentScope(self):
        """getAllInPortsComingFromOutsideOfCurrentScope(self) -> std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)>"""
        return _pilot.Node_getAllInPortsComingFromOutsideOfCurrentScope(self)

    def getSetOfLinksLeavingCurrentScope(self):
        """getSetOfLinksLeavingCurrentScope(self) -> linksvec"""
        return _pilot.Node_getSetOfLinksLeavingCurrentScope(self)

    def getSetOfLinksComingInCurrentScope(self):
        """getSetOfLinksComingInCurrentScope(self) -> linkvec"""
        return _pilot.Node_getSetOfLinksComingInCurrentScope(self)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.Node_getInputPort(self, *args)

    def getOutputPort(self, *args):
        """getOutputPort(self, string name) -> OutputPort"""
        return _pilot.Node_getOutputPort(self, *args)

    def getInputDataStreamPort(self, *args):
        """getInputDataStreamPort(self, string name) -> InputDataStreamPort"""
        return _pilot.Node_getInputDataStreamPort(self, *args)

    def getOutputDataStreamPort(self, *args):
        """getOutputDataStreamPort(self, string name) -> OutputDataStreamPort"""
        return _pilot.Node_getOutputDataStreamPort(self, *args)

    def getAllAscendanceOf(self, levelToStop = None):
        """
        getAllAscendanceOf(self, ComposedNode levelToStop = None) -> std::list<(p.YACS::ENGINE::ComposedNode,std::allocator<(p.YACS::ENGINE::ComposedNode)>)>
        getAllAscendanceOf(self) -> std::list<(p.YACS::ENGINE::ComposedNode,std::allocator<(p.YACS::ENGINE::ComposedNode)>)>
        """
        return _pilot.Node_getAllAscendanceOf(self, levelToStop)

    def __gt__(self, *args):
        """__gt__(self, Node other) -> bool"""
        return _pilot.Node___gt__(self, *args)

    def __lt__(self, *args):
        """__lt__(self, Node other) -> bool"""
        return _pilot.Node___lt__(self, *args)

    def getImplementation(self):
        """getImplementation(self) -> string"""
        return _pilot.Node_getImplementation(self)

    def getRootNode(self):
        """getRootNode(self) -> ComposedNode"""
        return _pilot.Node_getRootNode(self)

    def setProperty(self, *args):
        """setProperty(self, string name, string value)"""
        return _pilot.Node_setProperty(self, *args)

    def getProperty(self, *args):
        """getProperty(self, string name) -> string"""
        return _pilot.Node_getProperty(self, *args)

    def getProperties(self):
        """getProperties(self) -> propmap"""
        return _pilot.Node_getProperties(self)

    def getChildByName(self, *args):
        """getChildByName(self, string name) -> Node"""
        return _pilot.Node_getChildByName(self, *args)

    def getProc(self):
        """getProc(self) -> Proc"""
        return _pilot.Node_getProc(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.Node_accept(self, *args)

    def getQualifiedName(self):
        """getQualifiedName(self) -> string"""
        return _pilot.Node_getQualifiedName(self)

    def getNumId(self):
        """getNumId(self) -> int"""
        return _pilot.Node_getNumId(self)

    def sendEvent(self, *args):
        """sendEvent(self, string event)"""
        return _pilot.Node_sendEvent(self, *args)

    __swig_setmethods__["idMap"] = _pilot.Node_idMap_set
    __swig_getmethods__["idMap"] = _pilot.Node_idMap_get
    if _newclass:idMap = _swig_property(_pilot.Node_idMap_get, _pilot.Node_idMap_set)
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.Node_typeName(self)

    def getErrorDetails(self):
        """getErrorDetails(self) -> string"""
        return _pilot.Node_getErrorDetails(self)

    def setErrorDetails(self, *args):
        """setErrorDetails(self, string error)"""
        return _pilot.Node_setErrorDetails(self, *args)

    def modified(self):
        """modified(self)"""
        return _pilot.Node_modified(self)

    def isModified(self):
        """isModified(self) -> int"""
        return _pilot.Node_isModified(self)

    def isValid(self):
        """isValid(self) -> int"""
        return _pilot.Node_isValid(self)

    def edUpdateState(self):
        """edUpdateState(self)"""
        return _pilot.Node_edUpdateState(self)

    def getErrorReport(self):
        """getErrorReport(self) -> string"""
        return _pilot.Node_getErrorReport(self)

    def getContainerLog(self):
        """getContainerLog(self) -> string"""
        return _pilot.Node_getContainerLog(self)

    def ensureLoading(self):
        """ensureLoading(self)"""
        return _pilot.Node_ensureLoading(self)

    def getCoupledNodes(self, *args):
        """getCoupledNodes(self, std::set<(p.YACS::ENGINE::Task,std::less<(p.YACS::ENGINE::Task)>,std::allocator<(p.YACS::ENGINE::Task)>)> coupledNodes)"""
        return _pilot.Node_getCoupledNodes(self, *args)

    def cleanNodes(self):
        """cleanNodes(self)"""
        return _pilot.Node_cleanNodes(self)

    def __cmp__(self, *args):
        """__cmp__(self, Node other) -> int"""
        return _pilot.Node___cmp__(self, *args)

    def ptr(self):
        """ptr(self) -> long"""
        return _pilot.Node_ptr(self)

Node_swigregister = _pilot.Node_swigregister
Node_swigregister(Node)

def Node_getStateName(*args):
  """Node_getStateName(StatesForNode state) -> string"""
  return _pilot.Node_getStateName(*args)

class ElementaryNode(Node,Task):
    """Proxy of C++ YACS::ENGINE::ElementaryNode class"""
    __swig_setmethods__ = {}
    for _s in [Node,Task]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ElementaryNode, name, value)
    __swig_getmethods__ = {}
    for _s in [Node,Task]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ElementaryNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_ElementaryNode
    __del__ = lambda self : None;
    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.ElementaryNode_exUpdateState(self)

    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.ElementaryNode_init(self, start)

    def isDeployable(self):
        """isDeployable(self) -> bool"""
        return _pilot.ElementaryNode_isDeployable(self)

    def getComponent(self):
        """getComponent(self) -> ComponentInstance"""
        return _pilot.ElementaryNode_getComponent(self)

    def getContainer(self):
        """getContainer(self) -> Container"""
        return _pilot.ElementaryNode_getContainer(self)

    def getState(self):
        """getState(self) -> StatesForNode"""
        return _pilot.ElementaryNode_getState(self)

    def getReadyTasks(self, *args):
        """getReadyTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.ElementaryNode_getReadyTasks(self, *args)

    def edRemovePort(self, *args):
        """edRemovePort(self, Port port)"""
        return _pilot.ElementaryNode_edRemovePort(self, *args)

    def getRecursiveConstituents(self):
        """getRecursiveConstituents(self) -> std::list<(p.YACS::ENGINE::ElementaryNode,std::allocator<(p.YACS::ENGINE::ElementaryNode)>)>"""
        return _pilot.ElementaryNode_getRecursiveConstituents(self)

    def getChildByName(self, *args):
        """getChildByName(self, string name) -> Node"""
        return _pilot.ElementaryNode_getChildByName(self, *args)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.ElementaryNode_checkBasicConsistency(self)

    def getDynClonerIfExists(self, *args):
        """getDynClonerIfExists(self, ComposedNode levelToStop) -> ComposedNode"""
        return _pilot.ElementaryNode_getDynClonerIfExists(self, *args)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.ElementaryNode_getNumberOfInputPorts(self)

    def getNumberOfOutputPorts(self):
        """getNumberOfOutputPorts(self) -> int"""
        return _pilot.ElementaryNode_getNumberOfOutputPorts(self)

    def getInPortName(self, *args):
        """getInPortName(self, InPort arg0) -> string"""
        return _pilot.ElementaryNode_getInPortName(self, *args)

    def getOutPortName(self, *args):
        """getOutPortName(self, OutPort arg0) -> string"""
        return _pilot.ElementaryNode_getOutPortName(self, *args)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.ElementaryNode_getInputPort(self, *args)

    def getOutputPort(self, *args):
        """getOutputPort(self, string name) -> OutputPort"""
        return _pilot.ElementaryNode_getOutputPort(self, *args)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.ElementaryNode_getSetOfInputPort(self)

    def getSetOfOutputPort(self):
        """getSetOfOutputPort(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.ElementaryNode_getSetOfOutputPort(self)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.ElementaryNode_getLocalInputPorts(self)

    def getLocalOutputPorts(self):
        """getLocalOutputPorts(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.ElementaryNode_getLocalOutputPorts(self)

    def getAllOutPortsLeavingCurrentScope(self):
        """getAllOutPortsLeavingCurrentScope(self) -> std::set<(p.YACS::ENGINE::OutPort,std::less<(p.YACS::ENGINE::OutPort)>,std::allocator<(p.YACS::ENGINE::OutPort)>)>"""
        return _pilot.ElementaryNode_getAllOutPortsLeavingCurrentScope(self)

    def getAllInPortsComingFromOutsideOfCurrentScope(self):
        """getAllInPortsComingFromOutsideOfCurrentScope(self) -> std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)>"""
        return _pilot.ElementaryNode_getAllInPortsComingFromOutsideOfCurrentScope(self)

    def getSetOfLinksLeavingCurrentScope(self):
        """getSetOfLinksLeavingCurrentScope(self) -> linksvec"""
        return _pilot.ElementaryNode_getSetOfLinksLeavingCurrentScope(self)

    def getSetOfLinksComingInCurrentScope(self):
        """getSetOfLinksComingInCurrentScope(self) -> linkvec"""
        return _pilot.ElementaryNode_getSetOfLinksComingInCurrentScope(self)

    def getSetOfInputDataStreamPort(self):
        """getSetOfInputDataStreamPort(self) -> instreamlist"""
        return _pilot.ElementaryNode_getSetOfInputDataStreamPort(self)

    def getSetOfOutputDataStreamPort(self):
        """getSetOfOutputDataStreamPort(self) -> outstreamlist"""
        return _pilot.ElementaryNode_getSetOfOutputDataStreamPort(self)

    def getInputDataStreamPort(self, *args):
        """getInputDataStreamPort(self, string name) -> InputDataStreamPort"""
        return _pilot.ElementaryNode_getInputDataStreamPort(self, *args)

    def getOutputDataStreamPort(self, *args):
        """getOutputDataStreamPort(self, string name) -> OutputDataStreamPort"""
        return _pilot.ElementaryNode_getOutputDataStreamPort(self, *args)

    def createInputPort(self, *args):
        """createInputPort(self, string inputPortName, TypeCode type) -> InputPort"""
        return _pilot.ElementaryNode_createInputPort(self, *args)

    def createOutputPort(self, *args):
        """createOutputPort(self, string outputPortName, TypeCode type) -> OutputPort"""
        return _pilot.ElementaryNode_createOutputPort(self, *args)

    def createInputDataStreamPort(self, *args):
        """createInputDataStreamPort(self, string inputPortDSName, TypeCode type) -> InputDataStreamPort"""
        return _pilot.ElementaryNode_createInputDataStreamPort(self, *args)

    def createOutputDataStreamPort(self, *args):
        """createOutputDataStreamPort(self, string outputPortDSName, TypeCode type) -> OutputDataStreamPort"""
        return _pilot.ElementaryNode_createOutputDataStreamPort(self, *args)

    def edAddInputPort(self, *args):
        """edAddInputPort(self, string inputPortName, TypeCode type) -> InputPort"""
        return _pilot.ElementaryNode_edAddInputPort(self, *args)

    def edAddOutputPort(self, *args):
        """edAddOutputPort(self, string outputPortName, TypeCode type) -> OutputPort"""
        return _pilot.ElementaryNode_edAddOutputPort(self, *args)

    def edAddInputDataStreamPort(self, *args):
        """edAddInputDataStreamPort(self, string inputPortDSName, TypeCode type) -> InputDataStreamPort"""
        return _pilot.ElementaryNode_edAddInputDataStreamPort(self, *args)

    def edAddOutputDataStreamPort(self, *args):
        """edAddOutputDataStreamPort(self, string outputPortDSName, TypeCode type) -> OutputDataStreamPort"""
        return _pilot.ElementaryNode_edAddOutputDataStreamPort(self, *args)

    def edOrderInputPorts(self, *args):
        """edOrderInputPorts(self, std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)> ports)"""
        return _pilot.ElementaryNode_edOrderInputPorts(self, *args)

    def edOrderOutputPorts(self, *args):
        """edOrderOutputPorts(self, std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)> ports)"""
        return _pilot.ElementaryNode_edOrderOutputPorts(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ElementaryNode_typeName(self)

    def edUpdateState(self):
        """edUpdateState(self)"""
        return _pilot.ElementaryNode_edUpdateState(self)

    def ensureLoading(self):
        """ensureLoading(self)"""
        return _pilot.ElementaryNode_ensureLoading(self)

    def begin(self):
        """begin(self)"""
        return _pilot.ElementaryNode_begin(self)

    def isReady(self):
        """isReady(self) -> bool"""
        return _pilot.ElementaryNode_isReady(self)

    def finished(self):
        """finished(self)"""
        return _pilot.ElementaryNode_finished(self)

    def aborted(self):
        """aborted(self)"""
        return _pilot.ElementaryNode_aborted(self)

    def loaded(self):
        """loaded(self)"""
        return _pilot.ElementaryNode_loaded(self)

    def connected(self):
        """connected(self)"""
        return _pilot.ElementaryNode_connected(self)

    def getErrorDetails(self):
        """getErrorDetails(self) -> string"""
        return _pilot.ElementaryNode_getErrorDetails(self)

    def initService(self):
        """initService(self)"""
        return _pilot.ElementaryNode_initService(self)

    def connectService(self):
        """connectService(self)"""
        return _pilot.ElementaryNode_connectService(self)

    def disconnectService(self):
        """disconnectService(self)"""
        return _pilot.ElementaryNode_disconnectService(self)

    def load(self):
        """load(self)"""
        return _pilot.ElementaryNode_load(self)

    def getCoupledTasks(self, *args):
        """getCoupledTasks(self, std::set<(p.YACS::ENGINE::Task,std::less<(p.YACS::ENGINE::Task)>,std::allocator<(p.YACS::ENGINE::Task)>)> coupledSet)"""
        return _pilot.ElementaryNode_getCoupledTasks(self, *args)

    def getCoupledNodes(self, *args):
        """getCoupledNodes(self, std::set<(p.YACS::ENGINE::Task,std::less<(p.YACS::ENGINE::Task)>,std::allocator<(p.YACS::ENGINE::Task)>)> coupledSet)"""
        return _pilot.ElementaryNode_getCoupledNodes(self, *args)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.ElementaryNode_accept(self, *args)

ElementaryNode_swigregister = _pilot.ElementaryNode_swigregister
ElementaryNode_swigregister(ElementaryNode)

class InlineNode(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::InlineNode class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InlineNode, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InlineNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setScript(self, *args):
        """setScript(self, string script)"""
        return _pilot.InlineNode_setScript(self, *args)

    def getScript(self):
        """getScript(self) -> string"""
        return _pilot.InlineNode_getScript(self)

    def cloneNode(self, *args):
        """cloneNode(self, string name) -> InlineNode"""
        return _pilot.InlineNode_cloneNode(self, *args)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.InlineNode_accept(self, *args)

    __swig_destroy__ = _pilot.delete_InlineNode
    __del__ = lambda self : None;
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.InlineNode_typeName(self)

InlineNode_swigregister = _pilot.InlineNode_swigregister
InlineNode_swigregister(InlineNode)

class InlineFuncNode(InlineNode):
    """Proxy of C++ YACS::ENGINE::InlineFuncNode class"""
    __swig_setmethods__ = {}
    for _s in [InlineNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InlineFuncNode, name, value)
    __swig_getmethods__ = {}
    for _s in [InlineNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InlineFuncNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setFname(self, *args):
        """setFname(self, string fname)"""
        return _pilot.InlineFuncNode_setFname(self, *args)

    def getFname(self):
        """getFname(self) -> string"""
        return _pilot.InlineFuncNode_getFname(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.InlineFuncNode_accept(self, *args)

    __swig_destroy__ = _pilot.delete_InlineFuncNode
    __del__ = lambda self : None;
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.InlineFuncNode_typeName(self)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.InlineFuncNode_checkBasicConsistency(self)

    def setExecutionMode(self, *args):
        """setExecutionMode(self, string mode)"""
        return _pilot.InlineFuncNode_setExecutionMode(self, *args)

    def getExecutionMode(self):
        """getExecutionMode(self) -> string"""
        return _pilot.InlineFuncNode_getExecutionMode(self)

    def setContainer(self, *args):
        """setContainer(self, Container container)"""
        return _pilot.InlineFuncNode_setContainer(self, *args)

    def getContainer(self):
        """getContainer(self) -> Container"""
        return _pilot.InlineFuncNode_getContainer(self)

    def performDuplicationOfPlacement(self, *args):
        """performDuplicationOfPlacement(self, Node other)"""
        return _pilot.InlineFuncNode_performDuplicationOfPlacement(self, *args)

    def isDeployable(self):
        """isDeployable(self) -> bool"""
        return _pilot.InlineFuncNode_isDeployable(self)

InlineFuncNode_swigregister = _pilot.InlineFuncNode_swigregister
InlineFuncNode_swigregister(InlineFuncNode)

class ServiceNode(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::ServiceNode class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ServiceNode, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ServiceNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def load(self):
        """load(self)"""
        return _pilot.ServiceNode_load(self)

    def isDeployable(self):
        """isDeployable(self) -> bool"""
        return _pilot.ServiceNode_isDeployable(self)

    def setComponent(self, *args):
        """setComponent(self, ComponentInstance compo)"""
        return _pilot.ServiceNode_setComponent(self, *args)

    def getComponent(self):
        """getComponent(self) -> ComponentInstance"""
        return _pilot.ServiceNode_getComponent(self)

    def setRef(self, *args):
        """setRef(self, string ref)"""
        return _pilot.ServiceNode_setRef(self, *args)

    def getRef(self):
        """getRef(self) -> string"""
        return _pilot.ServiceNode_getRef(self)

    def setMethod(self, *args):
        """setMethod(self, string method)"""
        return _pilot.ServiceNode_setMethod(self, *args)

    def getMethod(self):
        """getMethod(self) -> string"""
        return _pilot.ServiceNode_getMethod(self)

    def createNode(self, *args):
        """createNode(self, string name) -> ServiceNode"""
        return _pilot.ServiceNode_createNode(self, *args)

    __swig_destroy__ = _pilot.delete_ServiceNode
    __del__ = lambda self : None;
    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.ServiceNode_accept(self, *args)

    def getKind(self):
        """getKind(self) -> string"""
        return _pilot.ServiceNode_getKind(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ServiceNode_typeName(self)

ServiceNode_swigregister = _pilot.ServiceNode_swigregister
ServiceNode_swigregister(ServiceNode)
ServiceNode.KIND = _pilot.cvar.ServiceNode_KIND

class ServiceInlineNode(ServiceNode):
    """Proxy of C++ YACS::ENGINE::ServiceInlineNode class"""
    __swig_setmethods__ = {}
    for _s in [ServiceNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ServiceInlineNode, name, value)
    __swig_getmethods__ = {}
    for _s in [ServiceNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ServiceInlineNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setScript(self, *args):
        """setScript(self, string script)"""
        return _pilot.ServiceInlineNode_setScript(self, *args)

    def getScript(self):
        """getScript(self) -> string"""
        return _pilot.ServiceInlineNode_getScript(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.ServiceInlineNode_accept(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ServiceInlineNode_typeName(self)

    __swig_destroy__ = _pilot.delete_ServiceInlineNode
    __del__ = lambda self : None;
ServiceInlineNode_swigregister = _pilot.ServiceInlineNode_swigregister
ServiceInlineNode_swigregister(ServiceInlineNode)

class ServerNode(InlineFuncNode):
    """Proxy of C++ YACS::ENGINE::ServerNode class"""
    __swig_setmethods__ = {}
    for _s in [InlineFuncNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ServerNode, name, value)
    __swig_getmethods__ = {}
    for _s in [InlineFuncNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ServerNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def performDuplicationOfPlacement(self, *args):
        """performDuplicationOfPlacement(self, Node other)"""
        return _pilot.ServerNode_performDuplicationOfPlacement(self, *args)

    def load(self):
        """load(self)"""
        return _pilot.ServerNode_load(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.ServerNode_accept(self, *args)

    def createNode(self, *args):
        """createNode(self, string name) -> ServerNode"""
        return _pilot.ServerNode_createNode(self, *args)

    def getContainer(self):
        """getContainer(self) -> Container"""
        return _pilot.ServerNode_getContainer(self)

    def setContainer(self, *args):
        """setContainer(self, Container container)"""
        return _pilot.ServerNode_setContainer(self, *args)

    def isDeployable(self):
        """isDeployable(self) -> bool"""
        return _pilot.ServerNode_isDeployable(self)

    def getEffectiveKindOfServer(self):
        """getEffectiveKindOfServer(self) -> string"""
        return _pilot.ServerNode_getEffectiveKindOfServer(self)

    __swig_destroy__ = _pilot.delete_ServerNode
    __del__ = lambda self : None;
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ServerNode_typeName(self)

ServerNode_swigregister = _pilot.ServerNode_swigregister
ServerNode_swigregister(ServerNode)

class DataNode(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::DataNode class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataNode, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DataNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def setData(self, *args):
        """
        setData(self, InputPort port, string data)
        setData(self, OutputPort port, string data)
        """
        return _pilot.DataNode_setData(self, *args)

    def setRef(self, *args):
        """setRef(self, string ref)"""
        return _pilot.DataNode_setRef(self, *args)

    def getRef(self):
        """getRef(self) -> string"""
        return _pilot.DataNode_getRef(self)

    __swig_destroy__ = _pilot.delete_DataNode
    __del__ = lambda self : None;
    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.DataNode_typeName(self)

DataNode_swigregister = _pilot.DataNode_swigregister
DataNode_swigregister(DataNode)

class ComposedNode(Node,Scheduler):
    """Proxy of C++ YACS::ENGINE::ComposedNode class"""
    __swig_setmethods__ = {}
    for _s in [Node,Scheduler]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComposedNode, name, value)
    __swig_getmethods__ = {}
    for _s in [Node,Scheduler]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ComposedNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_ComposedNode
    __del__ = lambda self : None;
    def isFinished(self):
        """isFinished(self) -> bool"""
        return _pilot.ComposedNode_isFinished(self)

    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.ComposedNode_init(self, start)

    def shutdown(self):
        """shutdown(self)"""
        return _pilot.ComposedNode_shutdown(self)

    def getName(self):
        """getName(self) -> string"""
        return _pilot.ComposedNode_getName(self)

    def getTaskName(self, *args):
        """getTaskName(self, Task task) -> string"""
        return _pilot.ComposedNode_getTaskName(self, *args)

    def getDeploymentTree(self):
        """getDeploymentTree(self) -> DeploymentTree"""
        return _pilot.ComposedNode_getDeploymentTree(self)

    def checkDeploymentTree(self, *args):
        """checkDeploymentTree(self, bool deep) -> DeploymentTree"""
        return _pilot.ComposedNode_checkDeploymentTree(self, *args)

    def getNextTasks(self, *args):
        """getNextTasks(self, bool isMore) -> std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)>"""
        return _pilot.ComposedNode_getNextTasks(self, *args)

    def isPlacementPredictableB4Run(self):
        """isPlacementPredictableB4Run(self) -> bool"""
        return _pilot.ComposedNode_isPlacementPredictableB4Run(self)

    def notifyFrom(self, *args):
        """notifyFrom(self, Task sender, Event event)"""
        return _pilot.ComposedNode_notifyFrom(self, *args)

    def edAddDFLink(self, *args):
        """edAddDFLink(self, OutPort start, InPort end) -> bool"""
        return _pilot.ComposedNode_edAddDFLink(self, *args)

    def edAddChild(self, *args):
        """edAddChild(self, Node DISOWNnode) -> bool"""
        return _pilot.ComposedNode_edAddChild(self, *args)

    def edRemoveChild(self, *args):
        """edRemoveChild(self, Node node)"""
        return _pilot.ComposedNode_edRemoveChild(self, *args)

    def edAddLink(self, *args):
        """
        edAddLink(self, OutPort start, InPort end) -> bool
        edAddLink(self, OutGate start, InGate end) -> bool
        """
        return _pilot.ComposedNode_edAddLink(self, *args)

    def edAddCFLink(self, *args):
        """edAddCFLink(self, Node nodeS, Node nodeE) -> bool"""
        return _pilot.ComposedNode_edAddCFLink(self, *args)

    def edRemoveCFLink(self, *args):
        """edRemoveCFLink(self, Node nodeS, Node nodeE)"""
        return _pilot.ComposedNode_edRemoveCFLink(self, *args)

    def edRemoveLink(self, *args):
        """
        edRemoveLink(self, OutPort start, InPort end)
        edRemoveLink(self, OutGate start, InGate end)
        """
        return _pilot.ComposedNode_edRemoveLink(self, *args)

    def isRepeatedUnpredictablySeveralTimes(self):
        """isRepeatedUnpredictablySeveralTimes(self) -> bool"""
        return _pilot.ComposedNode_isRepeatedUnpredictablySeveralTimes(self)

    def edGetDirectDescendants(self):
        """edGetDirectDescendants(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.ComposedNode_edGetDirectDescendants(self)

    def getRecursiveConstituents(self):
        """getRecursiveConstituents(self) -> std::list<(p.YACS::ENGINE::ElementaryNode,std::allocator<(p.YACS::ENGINE::ElementaryNode)>)>"""
        return _pilot.ComposedNode_getRecursiveConstituents(self)

    def getAllRecursiveNodes(self):
        """getAllRecursiveNodes(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.ComposedNode_getAllRecursiveNodes(self)

    def getAllRecursiveConstituents(self):
        """getAllRecursiveConstituents(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.ComposedNode_getAllRecursiveConstituents(self)

    def getInPortName(self, *args):
        """getInPortName(self, InPort arg0) -> string"""
        return _pilot.ComposedNode_getInPortName(self, *args)

    def getOutPortName(self, *args):
        """getOutPortName(self, OutPort arg0) -> string"""
        return _pilot.ComposedNode_getOutPortName(self, *args)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.ComposedNode_getNumberOfInputPorts(self)

    def getNumberOfOutputPorts(self):
        """getNumberOfOutputPorts(self) -> int"""
        return _pilot.ComposedNode_getNumberOfOutputPorts(self)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.ComposedNode_getSetOfInputPort(self)

    def getSetOfOutputPort(self):
        """getSetOfOutputPort(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.ComposedNode_getSetOfOutputPort(self)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.ComposedNode_getLocalInputPorts(self)

    def getLocalOutputPorts(self):
        """getLocalOutputPorts(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.ComposedNode_getLocalOutputPorts(self)

    def getAllOutPortsLeavingCurrentScope(self):
        """getAllOutPortsLeavingCurrentScope(self) -> std::set<(p.YACS::ENGINE::OutPort,std::less<(p.YACS::ENGINE::OutPort)>,std::allocator<(p.YACS::ENGINE::OutPort)>)>"""
        return _pilot.ComposedNode_getAllOutPortsLeavingCurrentScope(self)

    def getAllInPortsComingFromOutsideOfCurrentScope(self):
        """getAllInPortsComingFromOutsideOfCurrentScope(self) -> std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)>"""
        return _pilot.ComposedNode_getAllInPortsComingFromOutsideOfCurrentScope(self)

    def getSetOfInputDataStreamPort(self):
        """getSetOfInputDataStreamPort(self) -> instreamlist"""
        return _pilot.ComposedNode_getSetOfInputDataStreamPort(self)

    def getSetOfOutputDataStreamPort(self):
        """getSetOfOutputDataStreamPort(self) -> outstreamlist"""
        return _pilot.ComposedNode_getSetOfOutputDataStreamPort(self)

    def getOutPort(self, *args):
        """getOutPort(self, string name) -> OutPort"""
        return _pilot.ComposedNode_getOutPort(self, *args)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.ComposedNode_getInputPort(self, *args)

    def getOutputPort(self, *args):
        """getOutputPort(self, string name) -> OutputPort"""
        return _pilot.ComposedNode_getOutputPort(self, *args)

    def getInputDataStreamPort(self, *args):
        """getInputDataStreamPort(self, string name) -> InputDataStreamPort"""
        return _pilot.ComposedNode_getInputDataStreamPort(self, *args)

    def getOutputDataStreamPort(self, *args):
        """getOutputDataStreamPort(self, string name) -> OutputDataStreamPort"""
        return _pilot.ComposedNode_getOutputDataStreamPort(self, *args)

    def getSetOfInternalLinks(self):
        """getSetOfInternalLinks(self) -> linksvec"""
        return _pilot.ComposedNode_getSetOfInternalLinks(self)

    def getSetOfLinksLeavingCurrentScope(self):
        """getSetOfLinksLeavingCurrentScope(self) -> linksvec"""
        return _pilot.ComposedNode_getSetOfLinksLeavingCurrentScope(self)

    def checkConsistency(self, *args):
        """checkConsistency(self, LinkInfo info)"""
        return _pilot.ComposedNode_checkConsistency(self, *args)

    def getSetOfLinksComingInCurrentScope(self):
        """getSetOfLinksComingInCurrentScope(self) -> linkvec"""
        return _pilot.ComposedNode_getSetOfLinksComingInCurrentScope(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ComposedNode_typeName(self)

    def edUpdateState(self):
        """edUpdateState(self)"""
        return _pilot.ComposedNode_edUpdateState(self)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.ComposedNode_checkBasicConsistency(self)

    def getErrorReport(self):
        """getErrorReport(self) -> string"""
        return _pilot.ComposedNode_getErrorReport(self)

    def getRootNode(self):
        """getRootNode(self) -> ComposedNode"""
        return _pilot.ComposedNode_getRootNode(self)

    def isNodeAlreadyAggregated(self, *args):
        """isNodeAlreadyAggregated(self, Node node) -> bool"""
        return _pilot.ComposedNode_isNodeAlreadyAggregated(self, *args)

    def isNameAlreadyUsed(self, *args):
        """isNameAlreadyUsed(self, string name) -> bool"""
        return _pilot.ComposedNode_isNameAlreadyUsed(self, *args)

    def isInMyDescendance(self, *args):
        """isInMyDescendance(self, Node nodeToTest) -> Node"""
        return _pilot.ComposedNode_isInMyDescendance(self, *args)

    def getChildName(self, *args):
        """getChildName(self, Node node) -> string"""
        return _pilot.ComposedNode_getChildName(self, *args)

    def getMyQualifiedName(self, *args):
        """getMyQualifiedName(self, Node directSon) -> string"""
        return _pilot.ComposedNode_getMyQualifiedName(self, *args)

    def getChildByName(self, *args):
        """getChildByName(self, string name) -> Node"""
        return _pilot.ComposedNode_getChildByName(self, *args)

    def getLowestCommonAncestor(*args):
        """getLowestCommonAncestor(Node node1, Node node2) -> ComposedNode"""
        return _pilot.ComposedNode_getLowestCommonAncestor(*args)

    if _newclass:getLowestCommonAncestor = staticmethod(getLowestCommonAncestor)
    __swig_getmethods__["getLowestCommonAncestor"] = lambda x: getLowestCommonAncestor
    def loaded(self):
        """loaded(self)"""
        return _pilot.ComposedNode_loaded(self)

    def connected(self):
        """connected(self)"""
        return _pilot.ComposedNode_connected(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.ComposedNode_accept(self, *args)

    def cleanNodes(self):
        """cleanNodes(self)"""
        return _pilot.ComposedNode_cleanNodes(self)

ComposedNode_swigregister = _pilot.ComposedNode_swigregister
ComposedNode_swigregister(ComposedNode)

def ComposedNode_getLowestCommonAncestor(*args):
  """ComposedNode_getLowestCommonAncestor(Node node1, Node node2) -> ComposedNode"""
  return _pilot.ComposedNode_getLowestCommonAncestor(*args)

class StaticDefinedComposedNode(ComposedNode):
    """Proxy of C++ YACS::ENGINE::StaticDefinedComposedNode class"""
    __swig_setmethods__ = {}
    for _s in [ComposedNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, StaticDefinedComposedNode, name, value)
    __swig_getmethods__ = {}
    for _s in [ComposedNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, StaticDefinedComposedNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def isPlacementPredictableB4Run(self):
        """isPlacementPredictableB4Run(self) -> bool"""
        return _pilot.StaticDefinedComposedNode_isPlacementPredictableB4Run(self)

    def isMultiplicitySpecified(self, *args):
        """isMultiplicitySpecified(self, unsigned int value) -> bool"""
        return _pilot.StaticDefinedComposedNode_isMultiplicitySpecified(self, *args)

    def forceMultiplicity(self, *args):
        """forceMultiplicity(self, unsigned int value)"""
        return _pilot.StaticDefinedComposedNode_forceMultiplicity(self, *args)

    __swig_destroy__ = _pilot.delete_StaticDefinedComposedNode
    __del__ = lambda self : None;
StaticDefinedComposedNode_swigregister = _pilot.StaticDefinedComposedNode_swigregister
StaticDefinedComposedNode_swigregister(StaticDefinedComposedNode)

class Bloc(StaticDefinedComposedNode):
    """Proxy of C++ YACS::ENGINE::Bloc class"""
    __swig_setmethods__ = {}
    for _s in [StaticDefinedComposedNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bloc, name, value)
    __swig_getmethods__ = {}
    for _s in [StaticDefinedComposedNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Bloc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Bloc other, ComposedNode father, bool editionOnly) -> Bloc
        __init__(self, string name) -> Bloc
        """
        this = _pilot.new_Bloc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_Bloc
    __del__ = lambda self : None;
    def isFinished(self):
        """isFinished(self) -> bool"""
        return _pilot.Bloc_isFinished(self)

    def getNumberOfCFLinks(self):
        """getNumberOfCFLinks(self) -> int"""
        return _pilot.Bloc_getNumberOfCFLinks(self)

    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.Bloc_init(self, start)

    def getReadyTasks(self, *args):
        """getReadyTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Bloc_getReadyTasks(self, *args)

    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.Bloc_exUpdateState(self)

    def edAddChild(self, *args):
        """edAddChild(self, Node DISOWNnode) -> bool"""
        return _pilot.Bloc_edAddChild(self, *args)

    def edRemoveChild(self, *args):
        """edRemoveChild(self, Node node)"""
        val = _pilot.Bloc_edRemoveChild(self, *args)
        args[1].thisown=1


        return val

    def getChildren(self):
        """getChildren(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.Bloc_getChildren(self)

    def edGetDirectDescendants(self):
        """edGetDirectDescendants(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.Bloc_edGetDirectDescendants(self)

    def getChildByShortName(self, *args):
        """getChildByShortName(self, string name) -> Node"""
        return _pilot.Bloc_getChildByShortName(self, *args)

    def selectRunnableTasks(self, *args):
        """selectRunnableTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Bloc_selectRunnableTasks(self, *args)

    def writeDot(self, *args):
        """writeDot(self, std::ostream os)"""
        return _pilot.Bloc_writeDot(self, *args)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.Bloc_accept(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.Bloc_typeName(self)

Bloc_swigregister = _pilot.Bloc_swigregister
Bloc_swigregister(Bloc)

class Proc(Bloc):
    """Proxy of C++ YACS::ENGINE::Proc class"""
    __swig_setmethods__ = {}
    for _s in [Bloc]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Proc, name, value)
    __swig_getmethods__ = {}
    for _s in [Bloc]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Proc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string name) -> Proc"""
        this = _pilot.new_Proc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_Proc
    __del__ = lambda self : None;
    def createType(self, *args):
        """createType(self, string name, string kind) -> TypeCode"""
        return _pilot.Proc_createType(self, *args)

    def createInterfaceTc(self, *args):
        """createInterfaceTc(self, string id, string name, std::list<(p.YACS::ENGINE::TypeCodeObjref,std::allocator<(p.YACS::ENGINE::TypeCodeObjref)>)> ltc) -> TypeCode"""
        return _pilot.Proc_createInterfaceTc(self, *args)

    def createSequenceTc(self, *args):
        """createSequenceTc(self, string id, string name, TypeCode content) -> TypeCode"""
        return _pilot.Proc_createSequenceTc(self, *args)

    def createStructTc(self, *args):
        """createStructTc(self, string id, string name) -> TypeCode"""
        return _pilot.Proc_createStructTc(self, *args)

    def getTypeCode(self, *args):
        """getTypeCode(self, string name) -> TypeCode"""
        return _pilot.Proc_getTypeCode(self, *args)

    def setTypeCode(self, *args):
        """setTypeCode(self, string name, TypeCode t)"""
        return _pilot.Proc_setTypeCode(self, *args)

    def createContainer(self, *args):
        """
        createContainer(self, string name, string kind = "") -> Container
        createContainer(self, string name) -> Container
        """
        return _pilot.Proc_createContainer(self, *args)

    def createComponentInstance(self, *args):
        """
        createComponentInstance(self, string componame, string name = "", string kind = "") -> ComponentInstance
        createComponentInstance(self, string componame, string name = "") -> ComponentInstance
        createComponentInstance(self, string componame) -> ComponentInstance
        """
        return _pilot.Proc_createComponentInstance(self, *args)

    def addComponentInstance(self, *args):
        """
        addComponentInstance(self, ComponentInstance inst, string name = "", bool resetCtr = False)
        addComponentInstance(self, ComponentInstance inst, string name = "")
        addComponentInstance(self, ComponentInstance inst)
        """
        return _pilot.Proc_addComponentInstance(self, *args)

    def removeComponentInstance(self, *args):
        """removeComponentInstance(self, ComponentInstance inst)"""
        return _pilot.Proc_removeComponentInstance(self, *args)

    def removeContainer(self, *args):
        """removeContainer(self, Container cont)"""
        return _pilot.Proc_removeContainer(self, *args)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.Proc_accept(self, *args)

    def getProc(self):
        """getProc(self) -> Proc"""
        return _pilot.Proc_getProc(self)

    def getNodeState(self, *args):
        """getNodeState(self, int numId) -> StatesForNode"""
        return _pilot.Proc_getNodeState(self, *args)

    def getInPortValue(self, *args):
        """getInPortValue(self, int nodeNumId, string portName) -> string"""
        return _pilot.Proc_getInPortValue(self, *args)

    def setInPortValue(self, *args):
        """setInPortValue(self, string nodeName, string portName, string value) -> string"""
        return _pilot.Proc_setInPortValue(self, *args)

    def getOutPortValue(self, *args):
        """getOutPortValue(self, int nodeNumId, string portName) -> string"""
        return _pilot.Proc_getOutPortValue(self, *args)

    def getNodeErrorDetails(self, *args):
        """getNodeErrorDetails(self, int nodeNumId) -> string"""
        return _pilot.Proc_getNodeErrorDetails(self, *args)

    def getNodeErrorReport(self, *args):
        """getNodeErrorReport(self, int nodeNumId) -> string"""
        return _pilot.Proc_getNodeErrorReport(self, *args)

    def getNodeContainerLog(self, *args):
        """getNodeContainerLog(self, int nodeNumId) -> string"""
        return _pilot.Proc_getNodeContainerLog(self, *args)

    def getXMLState(self, *args):
        """getXMLState(self, int numId) -> string"""
        return _pilot.Proc_getXMLState(self, *args)

    def getNumIds(self):
        """getNumIds(self) -> __dummy_0__"""
        return _pilot.Proc_getNumIds(self)

    def getIds(self):
        """getIds(self) -> __dummy_1__"""
        return _pilot.Proc_getIds(self)

    def getLogger(self, *args):
        """getLogger(self, string name) -> Logger"""
        return _pilot.Proc_getLogger(self, *args)

    def writeDot(self, *args):
        """writeDot(self, std::ostream os)"""
        return _pilot.Proc_writeDot(self, *args)

    def setName(self, *args):
        """setName(self, string name)"""
        return _pilot.Proc_setName(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.Proc_typeName(self)

    __swig_setmethods__["nodeMap"] = _pilot.Proc_nodeMap_set
    __swig_getmethods__["nodeMap"] = _pilot.Proc_nodeMap_get
    if _newclass:nodeMap = _swig_property(_pilot.Proc_nodeMap_get, _pilot.Proc_nodeMap_set)
    __swig_setmethods__["serviceMap"] = _pilot.Proc_serviceMap_set
    __swig_getmethods__["serviceMap"] = _pilot.Proc_serviceMap_get
    if _newclass:serviceMap = _swig_property(_pilot.Proc_serviceMap_get, _pilot.Proc_serviceMap_set)
    __swig_setmethods__["inlineMap"] = _pilot.Proc_inlineMap_set
    __swig_getmethods__["inlineMap"] = _pilot.Proc_inlineMap_get
    if _newclass:inlineMap = _swig_property(_pilot.Proc_inlineMap_get, _pilot.Proc_inlineMap_set)
    __swig_setmethods__["typeMap"] = _pilot.Proc_typeMap_set
    __swig_getmethods__["typeMap"] = _pilot.Proc_typeMap_get
    if _newclass:typeMap = _swig_property(_pilot.Proc_typeMap_get, _pilot.Proc_typeMap_set)
    __swig_setmethods__["containerMap"] = _pilot.Proc_containerMap_set
    __swig_getmethods__["containerMap"] = _pilot.Proc_containerMap_get
    if _newclass:containerMap = _swig_property(_pilot.Proc_containerMap_get, _pilot.Proc_containerMap_set)
    __swig_setmethods__["componentInstanceMap"] = _pilot.Proc_componentInstanceMap_set
    __swig_getmethods__["componentInstanceMap"] = _pilot.Proc_componentInstanceMap_get
    if _newclass:componentInstanceMap = _swig_property(_pilot.Proc_componentInstanceMap_get, _pilot.Proc_componentInstanceMap_set)
    __swig_setmethods__["names"] = _pilot.Proc_names_set
    __swig_getmethods__["names"] = _pilot.Proc_names_get
    if _newclass:names = _swig_property(_pilot.Proc_names_get, _pilot.Proc_names_set)
    __swig_setmethods__["_loggers"] = _pilot.Proc__loggers_set
    __swig_getmethods__["_loggers"] = _pilot.Proc__loggers_get
    if _newclass:_loggers = _swig_property(_pilot.Proc__loggers_get, _pilot.Proc__loggers_set)
    def getEdition(self):
        """getEdition(self) -> bool"""
        return _pilot.Proc_getEdition(self)

    def setEdition(self, *args):
        """setEdition(self, bool edition)"""
        return _pilot.Proc_setEdition(self, *args)

    def modified(self):
        """modified(self)"""
        return _pilot.Proc_modified(self)

    def saveSchema(self, *args):
        """saveSchema(self, string xmlSchemaFile)"""
        return _pilot.Proc_saveSchema(self, *args)

    def saveState(self, *args):
        """saveState(self, string xmlStateFile)"""
        return _pilot.Proc_saveState(self, *args)

Proc_swigregister = _pilot.Proc_swigregister
Proc_swigregister(Proc)


def NbDoneLoader(*args):
  """NbDoneLoader(Loop node, int val)"""
  return _pilot.NbDoneLoader(*args)
class InputPort4DF2DS(InputPort):
    """Proxy of C++ YACS::ENGINE::InputPort4DF2DS class"""
    __swig_setmethods__ = {}
    for _s in [InputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputPort4DF2DS, name, value)
    __swig_getmethods__ = {}
    for _s in [InputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputPort4DF2DS, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, DFToDSForLoop node, TypeCode type) -> InputPort4DF2DS"""
        this = _pilot.new_InputPort4DF2DS(*args)
        try: self.this.append(this)
        except: self.this = this
    def getAllRepresentants(self, *args):
        """getAllRepresentants(self, std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)> repr)"""
        return _pilot.InputPort4DF2DS_getAllRepresentants(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _pilot.InputPort4DF2DS_clone(self, *args)

    def get(self):
        """get(self) -> void"""
        return _pilot.InputPort4DF2DS_get(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _pilot.InputPort4DF2DS_exRestoreInit(self)

    def exSaveInit(self):
        """exSaveInit(self)"""
        return _pilot.InputPort4DF2DS_exSaveInit(self)

    def put(self, *args):
        """
        put(self, void data)
        put(self, Any data)
        """
        return _pilot.InputPort4DF2DS_put(self, *args)

    __swig_destroy__ = _pilot.delete_InputPort4DF2DS
    __del__ = lambda self : None;
InputPort4DF2DS_swigregister = _pilot.InputPort4DF2DS_swigregister
InputPort4DF2DS_swigregister(InputPort4DF2DS)

class DFToDSForLoop(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::DFToDSForLoop class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DFToDSForLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DFToDSForLoop, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_DFToDSForLoop
    __del__ = lambda self : None;
DFToDSForLoop_swigregister = _pilot.DFToDSForLoop_swigregister
DFToDSForLoop_swigregister(DFToDSForLoop)

class OutputPort4DS2DF(OutputPort):
    """Proxy of C++ YACS::ENGINE::OutputPort4DS2DF class"""
    __swig_setmethods__ = {}
    for _s in [OutputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputPort4DS2DF, name, value)
    __swig_getmethods__ = {}
    for _s in [OutputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputPort4DS2DF, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, DSToDFForLoop node, TypeCode type) -> OutputPort4DS2DF"""
        this = _pilot.new_OutputPort4DS2DF(*args)
        try: self.this.append(this)
        except: self.this = this
    def getAllRepresented(self, *args):
        """getAllRepresented(self, std::set<(p.YACS::ENGINE::OutPort,std::less<(p.YACS::ENGINE::OutPort)>,std::allocator<(p.YACS::ENGINE::OutPort)>)> represented)"""
        return _pilot.OutputPort4DS2DF_getAllRepresented(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputPort"""
        return _pilot.OutputPort4DS2DF_clone(self, *args)

    def put(self, *args):
        """
        put(self, void data)
        put(self, Any data)
        """
        return _pilot.OutputPort4DS2DF_put(self, *args)

    __swig_destroy__ = _pilot.delete_OutputPort4DS2DF
    __del__ = lambda self : None;
OutputPort4DS2DF_swigregister = _pilot.OutputPort4DS2DF_swigregister
OutputPort4DS2DF_swigregister(OutputPort4DS2DF)

class InputDataStreamPort4DS2DF(InputDataStreamPort):
    """Proxy of C++ YACS::ENGINE::InputDataStreamPort4DS2DF class"""
    __swig_setmethods__ = {}
    for _s in [InputDataStreamPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputDataStreamPort4DS2DF, name, value)
    __swig_getmethods__ = {}
    for _s in [InputDataStreamPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputDataStreamPort4DS2DF, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, DSToDFForLoop node, TypeCode type) -> InputDataStreamPort4DS2DF"""
        this = _pilot.new_InputDataStreamPort4DS2DF(*args)
        try: self.this.append(this)
        except: self.this = this
    def getAllRepresentants(self, *args):
        """getAllRepresentants(self, std::set<(p.YACS::ENGINE::InPort,std::less<(p.YACS::ENGINE::InPort)>,std::allocator<(p.YACS::ENGINE::InPort)>)> repr)"""
        return _pilot.InputDataStreamPort4DS2DF_getAllRepresentants(self, *args)

    __swig_destroy__ = _pilot.delete_InputDataStreamPort4DS2DF
    __del__ = lambda self : None;
InputDataStreamPort4DS2DF_swigregister = _pilot.InputDataStreamPort4DS2DF_swigregister
InputDataStreamPort4DS2DF_swigregister(InputDataStreamPort4DS2DF)

class DSToDFForLoop(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::DSToDFForLoop class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DSToDFForLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DSToDFForLoop, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_DSToDFForLoop
    __del__ = lambda self : None;
DSToDFForLoop_swigregister = _pilot.DSToDFForLoop_swigregister
DSToDFForLoop_swigregister(DSToDFForLoop)

class FakeNodeForLoop(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::FakeNodeForLoop class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FakeNodeForLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FakeNodeForLoop, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_FakeNodeForLoop
    __del__ = lambda self : None;
FakeNodeForLoop_swigregister = _pilot.FakeNodeForLoop_swigregister
FakeNodeForLoop_swigregister(FakeNodeForLoop)

class Loop(StaticDefinedComposedNode):
    """Proxy of C++ YACS::ENGINE::Loop class"""
    __swig_setmethods__ = {}
    for _s in [StaticDefinedComposedNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Loop, name, value)
    __swig_getmethods__ = {}
    for _s in [StaticDefinedComposedNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Loop, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_Loop
    __del__ = lambda self : None;
    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.Loop_init(self, start)

    def getNbOfTurns(self):
        """getNbOfTurns(self) -> int"""
        return _pilot.Loop_getNbOfTurns(self)

    def edSetNode(self, *args):
        """edSetNode(self, Node DISOWNnode) -> Node"""
        return _pilot.Loop_edSetNode(self, *args)

    def edAddChild(self, *args):
        """edAddChild(self, Node DISOWNnode) -> bool"""
        return _pilot.Loop_edAddChild(self, *args)

    def edRemoveNode(self):
        """edRemoveNode(self) -> Node"""
        return _pilot.Loop_edRemoveNode(self)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.Loop_checkBasicConsistency(self)

    def getDecisionPort(self):
        """getDecisionPort(self) -> InputPort"""
        return _pilot.Loop_getDecisionPort(self)

    def getReadyTasks(self, *args):
        """getReadyTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Loop_getReadyTasks(self, *args)

    def edRemoveChild(self, *args):
        """edRemoveChild(self, Node node)"""
        return _pilot.Loop_edRemoveChild(self, *args)

    def isRepeatedUnpredictablySeveralTimes(self):
        """isRepeatedUnpredictablySeveralTimes(self) -> bool"""
        return _pilot.Loop_isRepeatedUnpredictablySeveralTimes(self)

    def selectRunnableTasks(self, *args):
        """selectRunnableTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Loop_selectRunnableTasks(self, *args)

    def edGetDirectDescendants(self):
        """edGetDirectDescendants(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.Loop_edGetDirectDescendants(self)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.Loop_getSetOfInputPort(self)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.Loop_getNumberOfInputPorts(self)

    def getChildByShortName(self, *args):
        """getChildByShortName(self, string name) -> Node"""
        return _pilot.Loop_getChildByShortName(self, *args)

    def MappingDF2DS(*args):
        """MappingDF2DS(TypeCode type) -> TypeCode"""
        return _pilot.Loop_MappingDF2DS(*args)

    if _newclass:MappingDF2DS = staticmethod(MappingDF2DS)
    __swig_getmethods__["MappingDF2DS"] = lambda x: MappingDF2DS
    def MappingDS2DF(*args):
        """MappingDS2DF(TypeCode type) -> TypeCode"""
        return _pilot.Loop_MappingDS2DF(*args)

    if _newclass:MappingDS2DF = staticmethod(MappingDS2DF)
    __swig_getmethods__["MappingDS2DF"] = lambda x: MappingDS2DF
    def edAddDFLink(self, *args):
        """edAddDFLink(self, OutPort start, InPort end) -> bool"""
        return _pilot.Loop_edAddDFLink(self, *args)

    def writeDot(self, *args):
        """writeDot(self, std::ostream os)"""
        return _pilot.Loop_writeDot(self, *args)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.Loop_accept(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.Loop_typeName(self)

Loop_swigregister = _pilot.Loop_swigregister
Loop_swigregister(Loop)

def Loop_MappingDF2DS(*args):
  """Loop_MappingDF2DS(TypeCode type) -> TypeCode"""
  return _pilot.Loop_MappingDF2DS(*args)

def Loop_MappingDS2DF(*args):
  """Loop_MappingDS2DF(TypeCode type) -> TypeCode"""
  return _pilot.Loop_MappingDS2DF(*args)

class ForLoop(Loop):
    """Proxy of C++ YACS::ENGINE::ForLoop class"""
    __swig_setmethods__ = {}
    for _s in [Loop]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ForLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [Loop]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ForLoop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, ForLoop other, ComposedNode father, bool editionOnly) -> ForLoop
        __init__(self, string name) -> ForLoop
        """
        this = _pilot.new_ForLoop(*args)
        try: self.this.append(this)
        except: self.this = this
    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.ForLoop_exUpdateState(self)

    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.ForLoop_init(self, start)

    def edGetNbOfTimesInputPort(self):
        """edGetNbOfTimesInputPort(self) -> InputPort"""
        return _pilot.ForLoop_edGetNbOfTimesInputPort(self)

    def simpleClone(self, *args):
        """
        simpleClone(self, ComposedNode father, bool editionOnly = True) -> Node
        simpleClone(self, ComposedNode father) -> Node
        """
        return _pilot.ForLoop_simpleClone(self, *args)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.ForLoop_getInputPort(self, *args)

    def getOutPort(self, *args):
        """getOutPort(self, string name) -> OutPort"""
        return _pilot.ForLoop_getOutPort(self, *args)

    def getOutputPort(self, *args):
        """getOutputPort(self, string name) -> OutputPort"""
        return _pilot.ForLoop_getOutputPort(self, *args)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.ForLoop_getLocalInputPorts(self)

    def getLocalOutputPorts(self):
        """getLocalOutputPorts(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.ForLoop_getLocalOutputPorts(self)

    def getSetOfOutputPort(self):
        """getSetOfOutputPort(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.ForLoop_getSetOfOutputPort(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.ForLoop_accept(self, *args)

    def getDecisionPort(self):
        """getDecisionPort(self) -> InputPort"""
        return _pilot.ForLoop_getDecisionPort(self)

    def edGetIndexPort(self):
        """edGetIndexPort(self) -> OutputPort"""
        return _pilot.ForLoop_edGetIndexPort(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ForLoop_typeName(self)

    __swig_destroy__ = _pilot.delete_ForLoop
    __del__ = lambda self : None;
ForLoop_swigregister = _pilot.ForLoop_swigregister
ForLoop_swigregister(ForLoop)

class DynParaLoop(ComposedNode):
    """Proxy of C++ YACS::ENGINE::DynParaLoop class"""
    __swig_setmethods__ = {}
    for _s in [ComposedNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DynParaLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [ComposedNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DynParaLoop, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def edRemoveNode(self):
        """edRemoveNode(self) -> Node"""
        return _pilot.DynParaLoop_edRemoveNode(self)

    def edRemoveInitNode(self):
        """edRemoveInitNode(self) -> Node"""
        return _pilot.DynParaLoop_edRemoveInitNode(self)

    def edSetNode(self, *args):
        """edSetNode(self, Node DISOWNnode) -> Node"""
        return _pilot.DynParaLoop_edSetNode(self, *args)

    def edSetInitNode(self, *args):
        """edSetInitNode(self, Node DISOWNnode) -> Node"""
        return _pilot.DynParaLoop_edSetInitNode(self, *args)

    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.DynParaLoop_init(self, start)

    def edGetNbOfBranchesPort(self):
        """edGetNbOfBranchesPort(self) -> InputPort"""
        return _pilot.DynParaLoop_edGetNbOfBranchesPort(self)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.DynParaLoop_getNumberOfInputPorts(self)

    def getNumberOfOutputPorts(self):
        """getNumberOfOutputPorts(self) -> int"""
        return _pilot.DynParaLoop_getNumberOfOutputPorts(self)

    def getNumberOfEltsConsumed(self):
        """getNumberOfEltsConsumed(self) -> unsigned int"""
        return _pilot.DynParaLoop_getNumberOfEltsConsumed(self)

    def getSetOfOutputPort(self):
        """getSetOfOutputPort(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.DynParaLoop_getSetOfOutputPort(self)

    def getLocalOutputPorts(self):
        """getLocalOutputPorts(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.DynParaLoop_getLocalOutputPorts(self)

    def edGetSamplePort(self):
        """edGetSamplePort(self) -> OutputPort"""
        return _pilot.DynParaLoop_edGetSamplePort(self)

    def getOutPort(self, *args):
        """getOutPort(self, string name) -> OutPort"""
        return _pilot.DynParaLoop_getOutPort(self, *args)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.DynParaLoop_getInputPort(self, *args)

    def getOutputPort(self, *args):
        """getOutputPort(self, string name) -> OutputPort"""
        return _pilot.DynParaLoop_getOutputPort(self, *args)

    def isPlacementPredictableB4Run(self):
        """isPlacementPredictableB4Run(self) -> bool"""
        return _pilot.DynParaLoop_isPlacementPredictableB4Run(self)

    def edRemoveChild(self, *args):
        """edRemoveChild(self, Node node)"""
        return _pilot.DynParaLoop_edRemoveChild(self, *args)

    def edAddChild(self, *args):
        """edAddChild(self, Node node) -> bool"""
        return _pilot.DynParaLoop_edAddChild(self, *args)

    def edGetDirectDescendants(self):
        """edGetDirectDescendants(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.DynParaLoop_edGetDirectDescendants(self)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.DynParaLoop_getSetOfInputPort(self)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.DynParaLoop_getLocalInputPorts(self)

    def getNumberOfBranchesCreatedDyn(self):
        """getNumberOfBranchesCreatedDyn(self) -> unsigned int"""
        return _pilot.DynParaLoop_getNumberOfBranchesCreatedDyn(self)

    def getChildByShortName(self, *args):
        """getChildByShortName(self, string name) -> Node"""
        return _pilot.DynParaLoop_getChildByShortName(self, *args)

    def getChildByNameExec(self, *args):
        """getChildByNameExec(self, string name, unsigned int id) -> Node"""
        return _pilot.DynParaLoop_getChildByNameExec(self, *args)

    def getNodes(self):
        """getNodes(self) -> std::vector<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.DynParaLoop_getNodes(self)

    def isMultiplicitySpecified(self, *args):
        """isMultiplicitySpecified(self, unsigned int value) -> bool"""
        return _pilot.DynParaLoop_isMultiplicitySpecified(self, *args)

    def forceMultiplicity(self, *args):
        """forceMultiplicity(self, unsigned int value)"""
        return _pilot.DynParaLoop_forceMultiplicity(self, *args)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.DynParaLoop_checkBasicConsistency(self)

    def getErrorReport(self):
        """getErrorReport(self) -> string"""
        return _pilot.DynParaLoop_getErrorReport(self)

DynParaLoop_swigregister = _pilot.DynParaLoop_swigregister
DynParaLoop_swigregister(DynParaLoop)

class WhileLoop(Loop):
    """Proxy of C++ YACS::ENGINE::WhileLoop class"""
    __swig_setmethods__ = {}
    for _s in [Loop]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WhileLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [Loop]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WhileLoop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, WhileLoop other, ComposedNode father, bool editionOnly) -> WhileLoop
        __init__(self, string name) -> WhileLoop
        """
        this = _pilot.new_WhileLoop(*args)
        try: self.this.append(this)
        except: self.this = this
    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.WhileLoop_exUpdateState(self)

    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.WhileLoop_init(self, start)

    def edGetConditionPort(self):
        """edGetConditionPort(self) -> InputPort"""
        return _pilot.WhileLoop_edGetConditionPort(self)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.WhileLoop_getInputPort(self, *args)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.WhileLoop_getLocalInputPorts(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.WhileLoop_accept(self, *args)

    def getDecisionPort(self):
        """getDecisionPort(self) -> InputPort"""
        return _pilot.WhileLoop_getDecisionPort(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.WhileLoop_typeName(self)

    __swig_destroy__ = _pilot.delete_WhileLoop
    __del__ = lambda self : None;
WhileLoop_swigregister = _pilot.WhileLoop_swigregister
WhileLoop_swigregister(WhileLoop)

class InterceptorInputPort(AnyInputPort):
    """Proxy of C++ YACS::ENGINE::InterceptorInputPort class"""
    __swig_setmethods__ = {}
    for _s in [AnyInputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InterceptorInputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [AnyInputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InterceptorInputPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_InterceptorInputPort
    __del__ = lambda self : None;
InterceptorInputPort_swigregister = _pilot.InterceptorInputPort_swigregister
InterceptorInputPort_swigregister(InterceptorInputPort)

class AnySplitOutputPort(OutputPort):
    """Proxy of C++ YACS::ENGINE::AnySplitOutputPort class"""
    __swig_setmethods__ = {}
    for _s in [OutputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, AnySplitOutputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [OutputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, AnySplitOutputPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_AnySplitOutputPort
    __del__ = lambda self : None;
AnySplitOutputPort_swigregister = _pilot.AnySplitOutputPort_swigregister
AnySplitOutputPort_swigregister(AnySplitOutputPort)

class SeqAnyInputPort(AnyInputPort):
    """Proxy of C++ YACS::ENGINE::SeqAnyInputPort class"""
    __swig_setmethods__ = {}
    for _s in [AnyInputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SeqAnyInputPort, name, value)
    __swig_getmethods__ = {}
    for _s in [AnyInputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SeqAnyInputPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getNumberOfElements(self):
        """getNumberOfElements(self) -> unsigned int"""
        return _pilot.SeqAnyInputPort_getNumberOfElements(self)

    def dump(self):
        """dump(self) -> string"""
        return _pilot.SeqAnyInputPort_dump(self)

    __swig_destroy__ = _pilot.delete_SeqAnyInputPort
    __del__ = lambda self : None;
SeqAnyInputPort_swigregister = _pilot.SeqAnyInputPort_swigregister
SeqAnyInputPort_swigregister(SeqAnyInputPort)

class SplitterNode(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::SplitterNode class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SplitterNode, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SplitterNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_SplitterNode
    __del__ = lambda self : None;
SplitterNode_swigregister = _pilot.SplitterNode_swigregister
SplitterNode_swigregister(SplitterNode)

class FakeNodeForForEachLoop(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::FakeNodeForForEachLoop class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FakeNodeForForEachLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FakeNodeForForEachLoop, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_FakeNodeForForEachLoop
    __del__ = lambda self : None;
FakeNodeForForEachLoop_swigregister = _pilot.FakeNodeForForEachLoop_swigregister
FakeNodeForForEachLoop_swigregister(FakeNodeForForEachLoop)

class ForEachLoop(DynParaLoop):
    """Proxy of C++ YACS::ENGINE::ForEachLoop class"""
    __swig_setmethods__ = {}
    for _s in [DynParaLoop]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ForEachLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [DynParaLoop]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ForEachLoop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, TypeCode typeOfDataSplitted) -> ForEachLoop
        __init__(self, ForEachLoop other, ComposedNode father, bool editionOnly) -> ForEachLoop
        """
        this = _pilot.new_ForEachLoop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_ForEachLoop
    __del__ = lambda self : None;
    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.ForEachLoop_init(self, start)

    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.ForEachLoop_exUpdateState(self)

    def getReadyTasks(self, *args):
        """getReadyTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.ForEachLoop_getReadyTasks(self, *args)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.ForEachLoop_getNumberOfInputPorts(self)

    def checkNoCyclePassingThrough(self, *args):
        """checkNoCyclePassingThrough(self, Node node)"""
        return _pilot.ForEachLoop_checkNoCyclePassingThrough(self, *args)

    def selectRunnableTasks(self, *args):
        """selectRunnableTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.ForEachLoop_selectRunnableTasks(self, *args)

    def getExecCurrentId(self):
        """getExecCurrentId(self) -> unsigned int"""
        return _pilot.ForEachLoop_getExecCurrentId(self)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.ForEachLoop_getSetOfInputPort(self)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.ForEachLoop_getLocalInputPorts(self)

    def edGetSeqOfSamplesPort(self):
        """edGetSeqOfSamplesPort(self) -> InputPort"""
        return _pilot.ForEachLoop_edGetSeqOfSamplesPort(self)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.ForEachLoop_getInputPort(self, *args)

    def getOutPort(self, *args):
        """getOutPort(self, string name) -> OutPort"""
        return _pilot.ForEachLoop_getOutPort(self, *args)

    def getOutputPort(self, *args):
        """getOutputPort(self, string name) -> OutputPort"""
        return _pilot.ForEachLoop_getOutputPort(self, *args)

    def getChildByShortName(self, *args):
        """getChildByShortName(self, string name) -> Node"""
        return _pilot.ForEachLoop_getChildByShortName(self, *args)

    def getLocalOutputPorts(self):
        """getLocalOutputPorts(self) -> std::list<(p.YACS::ENGINE::OutputPort,std::allocator<(p.YACS::ENGINE::OutputPort)>)>"""
        return _pilot.ForEachLoop_getLocalOutputPorts(self)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.ForEachLoop_accept(self, *args)

    def writeDot(self, *args):
        """writeDot(self, std::ostream os)"""
        return _pilot.ForEachLoop_writeDot(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.ForEachLoop_typeName(self)

ForEachLoop_swigregister = _pilot.ForEachLoop_swigregister
ForEachLoop_swigregister(ForEachLoop)
ForEachLoop.NAME_OF_SPLITTERNODE = _pilot.cvar.ForEachLoop_NAME_OF_SPLITTERNODE

EVENT_ORIENTED = _pilot.EVENT_ORIENTED
NOT_EVENT_ORIENTED = _pilot.NOT_EVENT_ORIENTED
class OptimizerAlgBase(RefCounter):
    """Proxy of C++ YACS::ENGINE::OptimizerAlgBase class"""
    __swig_setmethods__ = {}
    for _s in [RefCounter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizerAlgBase, name, value)
    __swig_getmethods__ = {}
    for _s in [RefCounter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizerAlgBase, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getTCForIn(self):
        """getTCForIn(self) -> TypeCode"""
        return _pilot.OptimizerAlgBase_getTCForIn(self)

    def getTCForOut(self):
        """getTCForOut(self) -> TypeCode"""
        return _pilot.OptimizerAlgBase_getTCForOut(self)

    def parseFileToInit(self, *args):
        """parseFileToInit(self, string fileName)"""
        return _pilot.OptimizerAlgBase_parseFileToInit(self, *args)

    def getType(self):
        """getType(self) -> TypeOfAlgInterface"""
        return _pilot.OptimizerAlgBase_getType(self)

    def initialize(self, *args):
        """initialize(self, Any input)"""
        return _pilot.OptimizerAlgBase_initialize(self, *args)

    def finish(self):
        """finish(self)"""
        return _pilot.OptimizerAlgBase_finish(self)

    def setPool(self, *args):
        """setPool(self, Pool pool)"""
        return _pilot.OptimizerAlgBase_setPool(self, *args)

OptimizerAlgBase_swigregister = _pilot.OptimizerAlgBase_swigregister
OptimizerAlgBase_swigregister(OptimizerAlgBase)

class OptimizerAlgSync(OptimizerAlgBase):
    """Proxy of C++ YACS::ENGINE::OptimizerAlgSync class"""
    __swig_setmethods__ = {}
    for _s in [OptimizerAlgBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizerAlgSync, name, value)
    __swig_getmethods__ = {}
    for _s in [OptimizerAlgBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizerAlgSync, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Pool pool) -> OptimizerAlgSync"""
        if self.__class__ == OptimizerAlgSync:
            _self = None
        else:
            _self = self
        this = _pilot.new_OptimizerAlgSync(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def getType(self):
        """getType(self) -> TypeOfAlgInterface"""
        return _pilot.OptimizerAlgSync_getType(self)

    __swig_destroy__ = _pilot.delete_OptimizerAlgSync
    __del__ = lambda self : None;
    def start(self):
        """start(self)"""
        return _pilot.OptimizerAlgSync_start(self)

    def takeDecision(self):
        """takeDecision(self)"""
        return _pilot.OptimizerAlgSync_takeDecision(self)

    def __disown__(self):
        self.this.disown()
        _pilot.disown_OptimizerAlgSync(self)
        return weakref_proxy(self)
OptimizerAlgSync_swigregister = _pilot.OptimizerAlgSync_swigregister
OptimizerAlgSync_swigregister(OptimizerAlgSync)

class OptimizerAlgASync(OptimizerAlgBase):
    """Proxy of C++ YACS::ENGINE::OptimizerAlgASync class"""
    __swig_setmethods__ = {}
    for _s in [OptimizerAlgBase]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizerAlgASync, name, value)
    __swig_getmethods__ = {}
    for _s in [OptimizerAlgBase]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizerAlgASync, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Pool pool) -> OptimizerAlgASync"""
        if self.__class__ == OptimizerAlgASync:
            _self = None
        else:
            _self = self
        this = _pilot.new_OptimizerAlgASync(_self, *args)
        try: self.this.append(this)
        except: self.this = this
    def getType(self):
        """getType(self) -> TypeOfAlgInterface"""
        return _pilot.OptimizerAlgASync_getType(self)

    __swig_destroy__ = _pilot.delete_OptimizerAlgASync
    __del__ = lambda self : None;
    def startToTakeDecision(self, *args):
        """startToTakeDecision(self, DrivenCondition condition)"""
        return _pilot.OptimizerAlgASync_startToTakeDecision(self, *args)

    def __disown__(self):
        self.this.disown()
        _pilot.disown_OptimizerAlgASync(self)
        return weakref_proxy(self)
OptimizerAlgASync_swigregister = _pilot.OptimizerAlgASync_swigregister
OptimizerAlgASync_swigregister(OptimizerAlgASync)

class OptimizerAlgStandardized(OptimizerAlgSync):
    """Proxy of C++ YACS::ENGINE::OptimizerAlgStandardized class"""
    __swig_setmethods__ = {}
    for _s in [OptimizerAlgSync]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizerAlgStandardized, name, value)
    __swig_getmethods__ = {}
    for _s in [OptimizerAlgSync]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizerAlgStandardized, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Pool pool, OptimizerAlgBase alg) -> OptimizerAlgStandardized"""
        this = _pilot.new_OptimizerAlgStandardized(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_OptimizerAlgStandardized
    __del__ = lambda self : None;
    def getTCForIn(self):
        """getTCForIn(self) -> TypeCode"""
        return _pilot.OptimizerAlgStandardized_getTCForIn(self)

    def getTCForOut(self):
        """getTCForOut(self) -> TypeCode"""
        return _pilot.OptimizerAlgStandardized_getTCForOut(self)

    def setAlgPointer(self, *args):
        """setAlgPointer(self, OptimizerAlgBase alg)"""
        return _pilot.OptimizerAlgStandardized_setAlgPointer(self, *args)

    def getAlg(self):
        """getAlg(self) -> OptimizerAlgBase"""
        return _pilot.OptimizerAlgStandardized_getAlg(self)

    def parseFileToInit(self, *args):
        """parseFileToInit(self, string fileName)"""
        return _pilot.OptimizerAlgStandardized_parseFileToInit(self, *args)

    def initialize(self, *args):
        """initialize(self, Any input)"""
        return _pilot.OptimizerAlgStandardized_initialize(self, *args)

    def takeDecision(self):
        """takeDecision(self)"""
        return _pilot.OptimizerAlgStandardized_takeDecision(self)

    def finish(self):
        """finish(self)"""
        return _pilot.OptimizerAlgStandardized_finish(self)

    def start(self):
        """start(self)"""
        return _pilot.OptimizerAlgStandardized_start(self)

OptimizerAlgStandardized_swigregister = _pilot.OptimizerAlgStandardized_swigregister
OptimizerAlgStandardized_swigregister(OptimizerAlgStandardized)

class FakeNodeForOptimizerLoop(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::FakeNodeForOptimizerLoop class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FakeNodeForOptimizerLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FakeNodeForOptimizerLoop, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_FakeNodeForOptimizerLoop
    __del__ = lambda self : None;
FakeNodeForOptimizerLoop_swigregister = _pilot.FakeNodeForOptimizerLoop_swigregister
FakeNodeForOptimizerLoop_swigregister(FakeNodeForOptimizerLoop)

class OptimizerLoop(DynParaLoop):
    """Proxy of C++ YACS::ENGINE::OptimizerLoop class"""
    __swig_setmethods__ = {}
    for _s in [DynParaLoop]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OptimizerLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [DynParaLoop]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OptimizerLoop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, string algLibWthOutExt, string symbolNameToOptimizerAlgBaseInstanceFactory, 
            bool algInitOnFile, 
            bool initAlgo = True) -> OptimizerLoop
        __init__(self, string name, string algLibWthOutExt, string symbolNameToOptimizerAlgBaseInstanceFactory, 
            bool algInitOnFile) -> OptimizerLoop
        __init__(self, OptimizerLoop other, ComposedNode father, bool editionOnly) -> OptimizerLoop
        """
        this = _pilot.new_OptimizerLoop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_OptimizerLoop
    __del__ = lambda self : None;
    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.OptimizerLoop_init(self, start)

    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.OptimizerLoop_exUpdateState(self)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.OptimizerLoop_getNumberOfInputPorts(self)

    def edGetPortForOutPool(self):
        """edGetPortForOutPool(self) -> InputPort"""
        return _pilot.OptimizerLoop_edGetPortForOutPool(self)

    def edGetPortForInitFile(self):
        """edGetPortForInitFile(self) -> InputPort"""
        return _pilot.OptimizerLoop_edGetPortForInitFile(self)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.OptimizerLoop_getInputPort(self, *args)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.OptimizerLoop_getSetOfInputPort(self)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.OptimizerLoop_getLocalInputPorts(self)

    def selectRunnableTasks(self, *args):
        """selectRunnableTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.OptimizerLoop_selectRunnableTasks(self, *args)

    def getReadyTasks(self, *args):
        """getReadyTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.OptimizerLoop_getReadyTasks(self, *args)

    def updateStateOnFinishedEventFrom(self, *args):
        """updateStateOnFinishedEventFrom(self, Node node) -> Event"""
        return _pilot.OptimizerLoop_updateStateOnFinishedEventFrom(self, *args)

    def checkNoCyclePassingThrough(self, *args):
        """checkNoCyclePassingThrough(self, Node node)"""
        return _pilot.OptimizerLoop_checkNoCyclePassingThrough(self, *args)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.OptimizerLoop_accept(self, *args)

    def getSymbol(self):
        """getSymbol(self) -> string"""
        return _pilot.OptimizerLoop_getSymbol(self)

    def getAlgLib(self):
        """getAlgLib(self) -> string"""
        return _pilot.OptimizerLoop_getAlgLib(self)

    def setAlgorithm(self, *args):
        """
        setAlgorithm(self, string alglib, string symbol, bool checkLinks = True)
        setAlgorithm(self, string alglib, string symbol)
        """
        return _pilot.OptimizerLoop_setAlgorithm(self, *args)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _pilot.OptimizerLoop_checkBasicConsistency(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.OptimizerLoop_typeName(self)

OptimizerLoop_swigregister = _pilot.OptimizerLoop_swigregister
OptimizerLoop_swigregister(OptimizerLoop)

class CollectorSwOutPort(OutPort):
    """Proxy of C++ YACS::ENGINE::CollectorSwOutPort class"""
    __swig_setmethods__ = {}
    for _s in [OutPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, CollectorSwOutPort, name, value)
    __swig_getmethods__ = {}
    for _s in [OutPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, CollectorSwOutPort, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def getHumanReprOfIncompleteCases(self, *args):
        """getHumanReprOfIncompleteCases(self, std::ostream stream)"""
        return _pilot.CollectorSwOutPort_getHumanReprOfIncompleteCases(self, *args)

    __swig_destroy__ = _pilot.delete_CollectorSwOutPort
    __del__ = lambda self : None;
CollectorSwOutPort_swigregister = _pilot.CollectorSwOutPort_swigregister
CollectorSwOutPort_swigregister(CollectorSwOutPort)

class FakeNodeForSwitch(ElementaryNode):
    """Proxy of C++ YACS::ENGINE::FakeNodeForSwitch class"""
    __swig_setmethods__ = {}
    for _s in [ElementaryNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FakeNodeForSwitch, name, value)
    __swig_getmethods__ = {}
    for _s in [ElementaryNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FakeNodeForSwitch, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_FakeNodeForSwitch
    __del__ = lambda self : None;
FakeNodeForSwitch_swigregister = _pilot.FakeNodeForSwitch_swigregister
FakeNodeForSwitch_swigregister(FakeNodeForSwitch)

class Switch(StaticDefinedComposedNode):
    """Proxy of C++ YACS::ENGINE::Switch class"""
    __swig_setmethods__ = {}
    for _s in [StaticDefinedComposedNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Switch, name, value)
    __swig_getmethods__ = {}
    for _s in [StaticDefinedComposedNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Switch, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, Switch other, ComposedNode father, bool editionOnly) -> Switch
        __init__(self, string name) -> Switch
        """
        this = _pilot.new_Switch(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_Switch
    __del__ = lambda self : None;
    def exUpdateState(self):
        """exUpdateState(self)"""
        return _pilot.Switch_exUpdateState(self)

    def init(self, start = True):
        """
        init(self, bool start = True)
        init(self)
        """
        return _pilot.Switch_init(self, start)

    def edSetDefaultNode(self, *args):
        """edSetDefaultNode(self, Node DISOWNnode) -> Node"""
        return _pilot.Switch_edSetDefaultNode(self, *args)

    def edReleaseDefaultNode(self):
        """edReleaseDefaultNode(self) -> Node"""
        return _pilot.Switch_edReleaseDefaultNode(self)

    def edReleaseCase(self, *args):
        """edReleaseCase(self, int caseId) -> Node"""
        return _pilot.Switch_edReleaseCase(self, *args)

    def edGetNode(self, *args):
        """edGetNode(self, int caseId) -> Node"""
        return _pilot.Switch_edGetNode(self, *args)

    def edSetNode(self, *args):
        """edSetNode(self, int caseId, Node DISOWNnode) -> Node"""
        return _pilot.Switch_edSetNode(self, *args)

    def edAddChild(self, *args):
        """edAddChild(self, Node DISOWNnode) -> bool"""
        return _pilot.Switch_edAddChild(self, *args)

    def getReadyTasks(self, *args):
        """getReadyTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Switch_getReadyTasks(self, *args)

    def selectRunnableTasks(self, *args):
        """selectRunnableTasks(self, std::vector<(p.YACS::ENGINE::Task,std::allocator<(p.YACS::ENGINE::Task)>)> tasks)"""
        return _pilot.Switch_selectRunnableTasks(self, *args)

    def edGetDirectDescendants(self):
        """edGetDirectDescendants(self) -> std::list<(p.YACS::ENGINE::Node,std::allocator<(p.YACS::ENGINE::Node)>)>"""
        return _pilot.Switch_edGetDirectDescendants(self)

    def edGetConditionPort(self):
        """edGetConditionPort(self) -> InputPort"""
        return _pilot.Switch_edGetConditionPort(self)

    def writeDot(self, *args):
        """writeDot(self, std::ostream os)"""
        return _pilot.Switch_writeDot(self, *args)

    def getNumberOfInputPorts(self):
        """getNumberOfInputPorts(self) -> int"""
        return _pilot.Switch_getNumberOfInputPorts(self)

    def edRemoveChild(self, *args):
        """edRemoveChild(self, Node node)"""
        return _pilot.Switch_edRemoveChild(self, *args)

    def getSetOfInputPort(self):
        """getSetOfInputPort(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.Switch_getSetOfInputPort(self)

    def getLocalInputPorts(self):
        """getLocalInputPorts(self) -> std::list<(p.YACS::ENGINE::InputPort,std::allocator<(p.YACS::ENGINE::InputPort)>)>"""
        return _pilot.Switch_getLocalInputPorts(self)

    def getEffectiveState(self, *args):
        """
        getEffectiveState(self) -> StatesForNode
        getEffectiveState(self, Node node) -> StatesForNode
        """
        return _pilot.Switch_getEffectiveState(self, *args)

    def getOutPort(self, *args):
        """getOutPort(self, string name) -> OutPort"""
        return _pilot.Switch_getOutPort(self, *args)

    def getInputPort(self, *args):
        """getInputPort(self, string name) -> InputPort"""
        return _pilot.Switch_getInputPort(self, *args)

    def getChildByShortName(self, *args):
        """getChildByShortName(self, string name) -> Node"""
        return _pilot.Switch_getChildByShortName(self, *args)

    def getMyQualifiedName(self, *args):
        """getMyQualifiedName(self, Node directSon) -> string"""
        return _pilot.Switch_getMyQualifiedName(self, *args)

    def getCaseId(self, *args):
        """getCaseId(self, Node node) -> string"""
        return _pilot.Switch_getCaseId(self, *args)

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _pilot.Switch_accept(self, *args)

    def getRankOfNode(self, *args):
        """getRankOfNode(self, Node node) -> int"""
        return _pilot.Switch_getRankOfNode(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _pilot.Switch_typeName(self)

Switch_swigregister = _pilot.Switch_swigregister
Switch_swigregister(Switch)
Switch.DEFAULT_NODE_NAME = _pilot.cvar.Switch_DEFAULT_NODE_NAME
Switch.SELECTOR_INPUTPORT_NAME = _pilot.cvar.Switch_SELECTOR_INPUTPORT_NAME
Switch.ID_FOR_DEFAULT_NODE = _pilot.cvar.Switch_ID_FOR_DEFAULT_NODE

class Visitor(_object):
    """Proxy of C++ YACS::ENGINE::Visitor class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Visitor, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Visitor, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def visitBloc(self, *args):
        """visitBloc(self, Bloc node)"""
        return _pilot.Visitor_visitBloc(self, *args)

    def visitElementaryNode(self, *args):
        """visitElementaryNode(self, ElementaryNode node)"""
        return _pilot.Visitor_visitElementaryNode(self, *args)

    def visitForEachLoop(self, *args):
        """visitForEachLoop(self, ForEachLoop node)"""
        return _pilot.Visitor_visitForEachLoop(self, *args)

    def visitOptimizerLoop(self, *args):
        """visitOptimizerLoop(self, OptimizerLoop node)"""
        return _pilot.Visitor_visitOptimizerLoop(self, *args)

    def visitForLoop(self, *args):
        """visitForLoop(self, ForLoop node)"""
        return _pilot.Visitor_visitForLoop(self, *args)

    def visitInlineNode(self, *args):
        """visitInlineNode(self, InlineNode node)"""
        return _pilot.Visitor_visitInlineNode(self, *args)

    def visitInlineFuncNode(self, *args):
        """visitInlineFuncNode(self, InlineFuncNode node)"""
        return _pilot.Visitor_visitInlineFuncNode(self, *args)

    def visitLoop(self, *args):
        """visitLoop(self, Loop node)"""
        return _pilot.Visitor_visitLoop(self, *args)

    def visitProc(self, *args):
        """visitProc(self, Proc node)"""
        return _pilot.Visitor_visitProc(self, *args)

    def visitServiceNode(self, *args):
        """visitServiceNode(self, ServiceNode node)"""
        return _pilot.Visitor_visitServiceNode(self, *args)

    def visitServerNode(self, *args):
        """visitServerNode(self, ServerNode node)"""
        return _pilot.Visitor_visitServerNode(self, *args)

    def visitServiceInlineNode(self, *args):
        """visitServiceInlineNode(self, ServiceInlineNode node)"""
        return _pilot.Visitor_visitServiceInlineNode(self, *args)

    def visitSwitch(self, *args):
        """visitSwitch(self, Switch node)"""
        return _pilot.Visitor_visitSwitch(self, *args)

    def visitWhileLoop(self, *args):
        """visitWhileLoop(self, WhileLoop node)"""
        return _pilot.Visitor_visitWhileLoop(self, *args)

    def visitPresetNode(self, *args):
        """visitPresetNode(self, DataNode node)"""
        return _pilot.Visitor_visitPresetNode(self, *args)

    def visitOutNode(self, *args):
        """visitOutNode(self, DataNode node)"""
        return _pilot.Visitor_visitOutNode(self, *args)

    def visitStudyInNode(self, *args):
        """visitStudyInNode(self, DataNode node)"""
        return _pilot.Visitor_visitStudyInNode(self, *args)

    def visitStudyOutNode(self, *args):
        """visitStudyOutNode(self, DataNode node)"""
        return _pilot.Visitor_visitStudyOutNode(self, *args)

    __swig_destroy__ = _pilot.delete_Visitor
    __del__ = lambda self : None;
Visitor_swigregister = _pilot.Visitor_swigregister
Visitor_swigregister(Visitor)

class DataLinkInfo(_object):
    """Proxy of C++ YACS::ENGINE::DataLinkInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataLinkInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DataLinkInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_from"] = _pilot.DataLinkInfo__from_set
    __swig_getmethods__["_from"] = _pilot.DataLinkInfo__from_get
    if _newclass:_from = _swig_property(_pilot.DataLinkInfo__from_get, _pilot.DataLinkInfo__from_set)
    __swig_setmethods__["to"] = _pilot.DataLinkInfo_to_set
    __swig_getmethods__["to"] = _pilot.DataLinkInfo_to_get
    if _newclass:to = _swig_property(_pilot.DataLinkInfo_to_get, _pilot.DataLinkInfo_to_set)
    __swig_setmethods__["outp"] = _pilot.DataLinkInfo_outp_set
    __swig_getmethods__["outp"] = _pilot.DataLinkInfo_outp_get
    if _newclass:outp = _swig_property(_pilot.DataLinkInfo_outp_get, _pilot.DataLinkInfo_outp_set)
    __swig_setmethods__["inp"] = _pilot.DataLinkInfo_inp_set
    __swig_getmethods__["inp"] = _pilot.DataLinkInfo_inp_get
    if _newclass:inp = _swig_property(_pilot.DataLinkInfo_inp_get, _pilot.DataLinkInfo_inp_set)
    __swig_setmethods__["toDelete"] = _pilot.DataLinkInfo_toDelete_set
    __swig_getmethods__["toDelete"] = _pilot.DataLinkInfo_toDelete_get
    if _newclass:toDelete = _swig_property(_pilot.DataLinkInfo_toDelete_get, _pilot.DataLinkInfo_toDelete_set)
    def __init__(self): 
        """__init__(self) -> DataLinkInfo"""
        this = _pilot.new_DataLinkInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_DataLinkInfo
    __del__ = lambda self : None;
DataLinkInfo_swigregister = _pilot.DataLinkInfo_swigregister
DataLinkInfo_swigregister(DataLinkInfo)

class StreamLinkInfo(_object):
    """Proxy of C++ YACS::ENGINE::StreamLinkInfo class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, StreamLinkInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, StreamLinkInfo, name)
    __repr__ = _swig_repr
    __swig_setmethods__["_from"] = _pilot.StreamLinkInfo__from_set
    __swig_getmethods__["_from"] = _pilot.StreamLinkInfo__from_get
    if _newclass:_from = _swig_property(_pilot.StreamLinkInfo__from_get, _pilot.StreamLinkInfo__from_set)
    __swig_setmethods__["to"] = _pilot.StreamLinkInfo_to_set
    __swig_getmethods__["to"] = _pilot.StreamLinkInfo_to_get
    if _newclass:to = _swig_property(_pilot.StreamLinkInfo_to_get, _pilot.StreamLinkInfo_to_set)
    __swig_setmethods__["outp"] = _pilot.StreamLinkInfo_outp_set
    __swig_getmethods__["outp"] = _pilot.StreamLinkInfo_outp_get
    if _newclass:outp = _swig_property(_pilot.StreamLinkInfo_outp_get, _pilot.StreamLinkInfo_outp_set)
    __swig_setmethods__["inp"] = _pilot.StreamLinkInfo_inp_set
    __swig_getmethods__["inp"] = _pilot.StreamLinkInfo_inp_get
    if _newclass:inp = _swig_property(_pilot.StreamLinkInfo_inp_get, _pilot.StreamLinkInfo_inp_set)
    __swig_setmethods__["toDelete"] = _pilot.StreamLinkInfo_toDelete_set
    __swig_getmethods__["toDelete"] = _pilot.StreamLinkInfo_toDelete_get
    if _newclass:toDelete = _swig_property(_pilot.StreamLinkInfo_toDelete_get, _pilot.StreamLinkInfo_toDelete_set)
    def __init__(self): 
        """__init__(self) -> StreamLinkInfo"""
        this = _pilot.new_StreamLinkInfo()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_StreamLinkInfo
    __del__ = lambda self : None;
StreamLinkInfo_swigregister = _pilot.StreamLinkInfo_swigregister
StreamLinkInfo_swigregister(StreamLinkInfo)

class VisitorSaveSchema(Visitor):
    """Proxy of C++ YACS::ENGINE::VisitorSaveSchema class"""
    __swig_setmethods__ = {}
    for _s in [Visitor]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, VisitorSaveSchema, name, value)
    __swig_getmethods__ = {}
    for _s in [Visitor]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, VisitorSaveSchema, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, ComposedNode root) -> VisitorSaveSchema"""
        this = _pilot.new_VisitorSaveSchema(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_VisitorSaveSchema
    __del__ = lambda self : None;
    def openFileSchema(self, *args):
        """openFileSchema(self, string xmlDump)"""
        return _pilot.VisitorSaveSchema_openFileSchema(self, *args)

    def closeFileSchema(self):
        """closeFileSchema(self)"""
        return _pilot.VisitorSaveSchema_closeFileSchema(self)

    def visitBloc(self, *args):
        """visitBloc(self, Bloc node)"""
        return _pilot.VisitorSaveSchema_visitBloc(self, *args)

    def visitElementaryNode(self, *args):
        """visitElementaryNode(self, ElementaryNode node)"""
        return _pilot.VisitorSaveSchema_visitElementaryNode(self, *args)

    def visitForEachLoop(self, *args):
        """visitForEachLoop(self, ForEachLoop node)"""
        return _pilot.VisitorSaveSchema_visitForEachLoop(self, *args)

    def visitOptimizerLoop(self, *args):
        """visitOptimizerLoop(self, OptimizerLoop node)"""
        return _pilot.VisitorSaveSchema_visitOptimizerLoop(self, *args)

    def visitForLoop(self, *args):
        """visitForLoop(self, ForLoop node)"""
        return _pilot.VisitorSaveSchema_visitForLoop(self, *args)

    def visitInlineNode(self, *args):
        """visitInlineNode(self, InlineNode node)"""
        return _pilot.VisitorSaveSchema_visitInlineNode(self, *args)

    def visitInlineFuncNode(self, *args):
        """visitInlineFuncNode(self, InlineFuncNode node)"""
        return _pilot.VisitorSaveSchema_visitInlineFuncNode(self, *args)

    def visitLoop(self, *args):
        """visitLoop(self, Loop node)"""
        return _pilot.VisitorSaveSchema_visitLoop(self, *args)

    def visitProc(self, *args):
        """visitProc(self, Proc node)"""
        return _pilot.VisitorSaveSchema_visitProc(self, *args)

    def visitServiceNode(self, *args):
        """visitServiceNode(self, ServiceNode node)"""
        return _pilot.VisitorSaveSchema_visitServiceNode(self, *args)

    def visitServerNode(self, *args):
        """visitServerNode(self, ServerNode node)"""
        return _pilot.VisitorSaveSchema_visitServerNode(self, *args)

    def visitServiceInlineNode(self, *args):
        """visitServiceInlineNode(self, ServiceInlineNode node)"""
        return _pilot.VisitorSaveSchema_visitServiceInlineNode(self, *args)

    def visitSwitch(self, *args):
        """visitSwitch(self, Switch node)"""
        return _pilot.VisitorSaveSchema_visitSwitch(self, *args)

    def visitWhileLoop(self, *args):
        """visitWhileLoop(self, WhileLoop node)"""
        return _pilot.VisitorSaveSchema_visitWhileLoop(self, *args)

    def visitPresetNode(self, *args):
        """visitPresetNode(self, DataNode node)"""
        return _pilot.VisitorSaveSchema_visitPresetNode(self, *args)

    def visitOutNode(self, *args):
        """visitOutNode(self, DataNode node)"""
        return _pilot.VisitorSaveSchema_visitOutNode(self, *args)

    def visitStudyInNode(self, *args):
        """visitStudyInNode(self, DataNode node)"""
        return _pilot.VisitorSaveSchema_visitStudyInNode(self, *args)

    def visitStudyOutNode(self, *args):
        """visitStudyOutNode(self, DataNode node)"""
        return _pilot.VisitorSaveSchema_visitStudyOutNode(self, *args)

VisitorSaveSchema_swigregister = _pilot.VisitorSaveSchema_swigregister
VisitorSaveSchema_swigregister(VisitorSaveSchema)

class SchemaSave(_object):
    """Proxy of C++ YACS::ENGINE::SchemaSave class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SchemaSave, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SchemaSave, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Proc proc) -> SchemaSave"""
        this = _pilot.new_SchemaSave(*args)
        try: self.this.append(this)
        except: self.this = this
    def save(self, *args):
        """save(self, string xmlSchemaFile)"""
        return _pilot.SchemaSave_save(self, *args)

    __swig_destroy__ = _pilot.delete_SchemaSave
    __del__ = lambda self : None;
SchemaSave_swigregister = _pilot.SchemaSave_swigregister
SchemaSave_swigregister(SchemaSave)

class ComponentDefinition(_object):
    """Proxy of C++ YACS::ENGINE::ComponentDefinition class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ComponentDefinition, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ComponentDefinition, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string name) -> ComponentDefinition"""
        this = _pilot.new_ComponentDefinition(*args)
        try: self.this.append(this)
        except: self.this = this
    def getName(self):
        """getName(self) -> string"""
        return _pilot.ComponentDefinition_getName(self)

    __swig_destroy__ = _pilot.delete_ComponentDefinition
    __del__ = lambda self : None;
    __swig_setmethods__["_serviceMap"] = _pilot.ComponentDefinition__serviceMap_set
    __swig_getmethods__["_serviceMap"] = _pilot.ComponentDefinition__serviceMap_get
    if _newclass:_serviceMap = _swig_property(_pilot.ComponentDefinition__serviceMap_get, _pilot.ComponentDefinition__serviceMap_set)
ComponentDefinition_swigregister = _pilot.ComponentDefinition_swigregister
ComponentDefinition_swigregister(ComponentDefinition)

class Catalog(_object):
    """Proxy of C++ YACS::ENGINE::Catalog class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Catalog, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Catalog, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string name) -> Catalog"""
        this = _pilot.new_Catalog(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_Catalog
    __del__ = lambda self : None;
    def getName(self):
        """getName(self) -> string"""
        return _pilot.Catalog_getName(self)

    def getErrors(self):
        """getErrors(self) -> string"""
        return _pilot.Catalog_getErrors(self)

    def setErrors(self, *args):
        """setErrors(self, string errors)"""
        return _pilot.Catalog_setErrors(self, *args)

    __swig_setmethods__["_typeMap"] = _pilot.Catalog__typeMap_set
    __swig_getmethods__["_typeMap"] = _pilot.Catalog__typeMap_get
    if _newclass:_typeMap = _swig_property(_pilot.Catalog__typeMap_get, _pilot.Catalog__typeMap_set)
    __swig_setmethods__["_componentMap"] = _pilot.Catalog__componentMap_set
    __swig_getmethods__["_componentMap"] = _pilot.Catalog__componentMap_get
    if _newclass:_componentMap = _swig_property(_pilot.Catalog__componentMap_get, _pilot.Catalog__componentMap_set)
    __swig_setmethods__["_nodeMap"] = _pilot.Catalog__nodeMap_set
    __swig_getmethods__["_nodeMap"] = _pilot.Catalog__nodeMap_get
    if _newclass:_nodeMap = _swig_property(_pilot.Catalog__nodeMap_get, _pilot.Catalog__nodeMap_set)
    __swig_setmethods__["_composednodeMap"] = _pilot.Catalog__composednodeMap_set
    __swig_getmethods__["_composednodeMap"] = _pilot.Catalog__composednodeMap_get
    if _newclass:_composednodeMap = _swig_property(_pilot.Catalog__composednodeMap_get, _pilot.Catalog__composednodeMap_set)
Catalog_swigregister = _pilot.Catalog_swigregister
Catalog_swigregister(Catalog)

class CatalogLoader(_object):
    """Proxy of C++ YACS::ENGINE::CatalogLoader class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CatalogLoader, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CatalogLoader, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _pilot.delete_CatalogLoader
    __del__ = lambda self : None;
    def newLoader(self, *args):
        """newLoader(self, string path) -> CatalogLoader"""
        return _pilot.CatalogLoader_newLoader(self, *args)

    def loadCata(self, *args):
        """loadCata(self, Catalog cata)"""
        return _pilot.CatalogLoader_loadCata(self, *args)

    def load(self, *args):
        """load(self, Catalog cata, string path)"""
        return _pilot.CatalogLoader_load(self, *args)

CatalogLoader_swigregister = _pilot.CatalogLoader_swigregister
CatalogLoader_swigregister(CatalogLoader)

class Pool(_object):
    """Proxy of C++ YACS::ENGINE::Pool class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Pool, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Pool, name)
    __repr__ = _swig_repr
    def getCurrentId(self):
        """getCurrentId(self) -> int"""
        return _pilot.Pool_getCurrentId(self)

    def getCurrentInSample(self):
        """getCurrentInSample(self) -> Any"""
        return _pilot.Pool_getCurrentInSample(self)

    def getCurrentOutSample(self):
        """getCurrentOutSample(self) -> Any"""
        return _pilot.Pool_getCurrentOutSample(self)

    def pushInSample(self, *args):
        """
        pushInSample(self, int id, Any inSample, unsigned char priority = 0)
        pushInSample(self, int id, Any inSample)
        """
        return _pilot.Pool_pushInSample(self, *args)

    def destroyAll(self):
        """destroyAll(self)"""
        return _pilot.Pool_destroyAll(self)

    def __init__(self): 
        """__init__(self) -> Pool"""
        this = _pilot.new_Pool()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _pilot.delete_Pool
    __del__ = lambda self : None;
Pool_swigregister = _pilot.Pool_swigregister
Pool_swigregister(Pool)



