# 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.

"""
Implementation of nodes for SALOME platform.
"""

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('_SALOMERuntime', [dirname(__file__)])
        except ImportError:
            import _SALOMERuntime
            return _SALOMERuntime
        if fp is not None:
            try:
                _mod = imp.load_module('_SALOMERuntime', fp, pathname, description)
            finally:
                fp.close()
                return _mod
    _SALOMERuntime = swig_import_helper()
    del swig_import_helper
else:
    import _SALOMERuntime
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 SALOMERuntime_PySwigIterator(_object):
    """Proxy of C++ swig::SALOMERuntime_PySwigIterator class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SALOMERuntime_PySwigIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SALOMERuntime_PySwigIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _SALOMERuntime.delete_SALOMERuntime_PySwigIterator
    __del__ = lambda self : None;
    def value(self):
        """value(self) -> PyObject"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_value(self)

    def incr(self, n = 1):
        """
        incr(self, size_t n = 1) -> SALOMERuntime_PySwigIterator
        incr(self) -> SALOMERuntime_PySwigIterator
        """
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_incr(self, n)

    def decr(self, n = 1):
        """
        decr(self, size_t n = 1) -> SALOMERuntime_PySwigIterator
        decr(self) -> SALOMERuntime_PySwigIterator
        """
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_decr(self, n)

    def distance(self, *args):
        """distance(self, SALOMERuntime_PySwigIterator x) -> ptrdiff_t"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_distance(self, *args)

    def equal(self, *args):
        """equal(self, SALOMERuntime_PySwigIterator x) -> bool"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_equal(self, *args)

    def copy(self):
        """copy(self) -> SALOMERuntime_PySwigIterator"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_copy(self)

    def next(self):
        """next(self) -> PyObject"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_next(self)

    def __next__(self):
        """__next__(self) -> PyObject"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator___next__(self)

    def previous(self):
        """previous(self) -> PyObject"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_previous(self)

    def advance(self, *args):
        """advance(self, ptrdiff_t n) -> SALOMERuntime_PySwigIterator"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator_advance(self, *args)

    def __eq__(self, *args):
        """__eq__(self, SALOMERuntime_PySwigIterator x) -> bool"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator___eq__(self, *args)

    def __ne__(self, *args):
        """__ne__(self, SALOMERuntime_PySwigIterator x) -> bool"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator___ne__(self, *args)

    def __iadd__(self, *args):
        """__iadd__(self, ptrdiff_t n) -> SALOMERuntime_PySwigIterator"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator___iadd__(self, *args)

    def __isub__(self, *args):
        """__isub__(self, ptrdiff_t n) -> SALOMERuntime_PySwigIterator"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator___isub__(self, *args)

    def __add__(self, *args):
        """__add__(self, ptrdiff_t n) -> SALOMERuntime_PySwigIterator"""
        return _SALOMERuntime.SALOMERuntime_PySwigIterator___add__(self, *args)

    def __sub__(self, *args):
        """
        __sub__(self, ptrdiff_t n) -> SALOMERuntime_PySwigIterator
        __sub__(self, SALOMERuntime_PySwigIterator x) -> ptrdiff_t
        """
        return _SALOMERuntime.SALOMERuntime_PySwigIterator___sub__(self, *args)

    def __iter__(self): return self
SALOMERuntime_PySwigIterator_swigregister = _SALOMERuntime.SALOMERuntime_PySwigIterator_swigregister
SALOMERuntime_PySwigIterator_swigregister(SALOMERuntime_PySwigIterator)

import pilot
class SalomeContainer(pilot.Container):
    """Proxy of C++ YACS::ENGINE::SalomeContainer class"""
    __swig_setmethods__ = {}
    for _s in [pilot.Container]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SalomeContainer, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.Container]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SalomeContainer, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self) -> SalomeContainer
        __init__(self, SalomeContainer other) -> SalomeContainer
        """
        this = _SALOMERuntime.new_SalomeContainer(*args)
        try: self.this.append(this)
        except: self.this = this
    def lock(self):
        """lock(self)"""
        return _SALOMERuntime.SalomeContainer_lock(self)

    def unLock(self):
        """unLock(self)"""
        return _SALOMERuntime.SalomeContainer_unLock(self)

    def isAlreadyStarted(self, *args):
        """isAlreadyStarted(self, ComponentInstance inst) -> bool"""
        return _SALOMERuntime.SalomeContainer_isAlreadyStarted(self, *args)

    def getContainerPtr(self, *args):
        """getContainerPtr(self, ComponentInstance inst) -> Engines::Container_ptr"""
        return _SALOMERuntime.SalomeContainer_getContainerPtr(self, *args)

    def start(self, *args):
        """start(self, ComponentInstance inst)"""
        return _SALOMERuntime.SalomeContainer_start(self, *args)

    def clone(self):
        """clone(self) -> Container"""
        return _SALOMERuntime.SalomeContainer_clone(self)

    def getPlacementId(self, *args):
        """getPlacementId(self, ComponentInstance inst) -> string"""
        return _SALOMERuntime.SalomeContainer_getPlacementId(self, *args)

    def checkCapabilityToDealWith(self, *args):
        """checkCapabilityToDealWith(self, ComponentInstance inst)"""
        return _SALOMERuntime.SalomeContainer_checkCapabilityToDealWith(self, *args)

    def setProperty(self, *args):
        """setProperty(self, string name, string value)"""
        return _SALOMERuntime.SalomeContainer_setProperty(self, *args)

    def addComponentName(self, *args):
        """addComponentName(self, string name)"""
        return _SALOMERuntime.SalomeContainer_addComponentName(self, *args)

    def loadComponent(self, *args):
        """loadComponent(self, ComponentInstance inst) -> CORBA::Object_ptr"""
        return _SALOMERuntime.SalomeContainer_loadComponent(self, *args)

    __swig_setmethods__["_params"] = _SALOMERuntime.SalomeContainer__params_set
    __swig_getmethods__["_params"] = _SALOMERuntime.SalomeContainer__params_get
    if _newclass:_params = _swig_property(_SALOMERuntime.SalomeContainer__params_get, _SALOMERuntime.SalomeContainer__params_set)
    __swig_destroy__ = _SALOMERuntime.delete_SalomeContainer
    __del__ = lambda self : None;
SalomeContainer_swigregister = _SALOMERuntime.SalomeContainer_swigregister
SalomeContainer_swigregister(SalomeContainer)


def getSALOMERuntime():
  """getSALOMERuntime() -> RuntimeSALOME"""
  return _SALOMERuntime.getSALOMERuntime()
class RuntimeSALOME(pilot.Runtime):
    """Proxy of C++ YACS::ENGINE::RuntimeSALOME class"""
    __swig_setmethods__ = {}
    for _s in [pilot.Runtime]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, RuntimeSALOME, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.Runtime]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, RuntimeSALOME, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    IsPyExt = _SALOMERuntime.RuntimeSALOME_IsPyExt
    UsePython = _SALOMERuntime.RuntimeSALOME_UsePython
    UseCorba = _SALOMERuntime.RuntimeSALOME_UseCorba
    UseXml = _SALOMERuntime.RuntimeSALOME_UseXml
    UseCpp = _SALOMERuntime.RuntimeSALOME_UseCpp
    UseSalome = _SALOMERuntime.RuntimeSALOME_UseSalome
    __swig_setmethods__["FLAGS"] = _SALOMERuntime.RuntimeSALOME_FLAGS_set
    __swig_getmethods__["FLAGS"] = _SALOMERuntime.RuntimeSALOME_FLAGS_get
    if _newclass:FLAGS = _swig_property(_SALOMERuntime.RuntimeSALOME_FLAGS_get, _SALOMERuntime.RuntimeSALOME_FLAGS_set)
    def setRuntime(*args):
        """
        setRuntime(long flags = YACS::ENGINE::RuntimeSALOME::UsePython+YACS::ENGINE::RuntimeSALOME::UseCorba+YACS::ENGINE::RuntimeSALOME::UseXml+YACS::ENGINE::RuntimeSALOME::UseCpp+YACS::ENGINE::RuntimeSALOME::UseSalome)
        setRuntime()
        """
        return _SALOMERuntime.RuntimeSALOME_setRuntime(*args)

    if _newclass:setRuntime = staticmethod(setRuntime)
    __swig_getmethods__["setRuntime"] = lambda x: setRuntime
    def init(self, *args):
        """init(self, long flags)"""
        return _SALOMERuntime.RuntimeSALOME_init(self, *args)

    def fini(self):
        """fini(self)"""
        return _SALOMERuntime.RuntimeSALOME_fini(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def createForLoop(self, *args):
        """createForLoop(self, string name) -> ForLoop"""
        return _SALOMERuntime.RuntimeSALOME_createForLoop(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 _SALOMERuntime.RuntimeSALOME_createOptimizerLoop(self, *args)

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

    def createProc(self, *args):
        """createProc(self, string name) -> Proc"""
        return _SALOMERuntime.RuntimeSALOME_createProc(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 _SALOMERuntime.RuntimeSALOME_createInterfaceTc(self, *args)

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

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

    def adaptNeutral(self, *args):
        """adaptNeutral(self, InputPort source, string impl, TypeCode type, bool init) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptNeutral(self, *args)

    def adaptCorbaToCorba(self, *args):
        """adaptCorbaToCorba(self, InputCorbaPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCorbaToCorba(self, *args)

    def adaptCorbaToNeutral(self, *args):
        """adaptCorbaToNeutral(self, InputCorbaPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCorbaToNeutral(self, *args)

    def adaptCorbaToPython(self, *args):
        """adaptCorbaToPython(self, InputCorbaPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCorbaToPython(self, *args)

    def adaptCorbaToCpp(self, *args):
        """adaptCorbaToCpp(self, InputCorbaPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCorbaToCpp(self, *args)

    def adaptCorbaToXml(self, *args):
        """adaptCorbaToXml(self, InputCorbaPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCorbaToXml(self, *args)

    def adaptPythonToCorba(self, *args):
        """adaptPythonToCorba(self, InputPyPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptPythonToCorba(self, *args)

    def adaptPythonToNeutral(self, *args):
        """adaptPythonToNeutral(self, InputPyPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptPythonToNeutral(self, *args)

    def adaptPythonToPython(self, *args):
        """adaptPythonToPython(self, InputPyPort source, TypeCode type, bool init) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptPythonToPython(self, *args)

    def adaptPythonToXml(self, *args):
        """adaptPythonToXml(self, InputPyPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptPythonToXml(self, *args)

    def adaptPythonToCpp(self, *args):
        """adaptPythonToCpp(self, InputPyPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptPythonToCpp(self, *args)

    def adaptCppToCorba(self, *args):
        """adaptCppToCorba(self, InputCppPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCppToCorba(self, *args)

    def adaptCppToNeutral(self, *args):
        """adaptCppToNeutral(self, InputCppPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCppToNeutral(self, *args)

    def adaptCppToPython(self, *args):
        """adaptCppToPython(self, InputCppPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCppToPython(self, *args)

    def adaptCppToXml(self, *args):
        """adaptCppToXml(self, InputCppPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCppToXml(self, *args)

    def adaptCppToCpp(self, *args):
        """adaptCppToCpp(self, InputCppPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptCppToCpp(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
        adapt(self, InputCorbaPort source, string impl, TypeCode type, 
            bool init) -> InputPort
        adapt(self, InputPyPort source, string impl, TypeCode type, bool init) -> InputPort
        adapt(self, InputCppPort source, string impl, TypeCode type, bool init) -> InputPort
        adapt(self, InputXmlPort source, string impl, TypeCode type, bool init) -> InputPort
        """
        return _SALOMERuntime.RuntimeSALOME_adapt(self, *args)

    def adaptXmlToCorba(self, *args):
        """adaptXmlToCorba(self, InputXmlPort source, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptXmlToCorba(self, *args)

    def adaptXmlToPython(self, *args):
        """adaptXmlToPython(self, InputXmlPort inport, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptXmlToPython(self, *args)

    def adaptXmlToCpp(self, *args):
        """adaptXmlToCpp(self, InputXmlPort inport, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptXmlToCpp(self, *args)

    def adaptXmlToNeutral(self, *args):
        """adaptXmlToNeutral(self, InputXmlPort inport, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptXmlToNeutral(self, *args)

    def adaptXmlToXml(self, *args):
        """adaptXmlToXml(self, InputXmlPort inport, TypeCode type, bool init) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptXmlToXml(self, *args)

    def adaptNeutralToXml(self, *args):
        """adaptNeutralToXml(self, InputPort inport, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptNeutralToXml(self, *args)

    def adaptNeutralToPython(self, *args):
        """adaptNeutralToPython(self, InputPort inport, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptNeutralToPython(self, *args)

    def adaptNeutralToCorba(self, *args):
        """adaptNeutralToCorba(self, InputPort inport, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptNeutralToCorba(self, *args)

    def adaptNeutralToCpp(self, *args):
        """adaptNeutralToCpp(self, InputPort inport, TypeCode type) -> InputPort"""
        return _SALOMERuntime.RuntimeSALOME_adaptNeutralToCpp(self, *args)

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

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

    def convertPyObjectToString(self, *args):
        """convertPyObjectToString(self, PyObject ob) -> string"""
        return _SALOMERuntime.RuntimeSALOME_convertPyObjectToString(self, *args)

    def convertStringToPyObject(self, *args):
        """convertStringToPyObject(self, string s) -> PyObject"""
        return _SALOMERuntime.RuntimeSALOME_convertStringToPyObject(self, *args)

    __swig_destroy__ = _SALOMERuntime.delete_RuntimeSALOME
    __del__ = lambda self : None;
    def getOrb(self):
        """getOrb(self) -> CORBA::ORB_ptr"""
        return _SALOMERuntime.RuntimeSALOME_getOrb(self)

    def getPyOrb(self):
        """getPyOrb(self) -> PyObject"""
        return _SALOMERuntime.RuntimeSALOME_getPyOrb(self)

    def getBuiltins(self):
        """getBuiltins(self) -> PyObject"""
        return _SALOMERuntime.RuntimeSALOME_getBuiltins(self)

    def getDynFactory(self):
        """getDynFactory(self) -> DynamicAny::DynAnyFactory_ptr"""
        return _SALOMERuntime.RuntimeSALOME_getDynFactory(self)

    def getApi(self):
        """getApi(self)"""
        return _SALOMERuntime.RuntimeSALOME_getApi(self)

    def get_omnipy(self):
        """get_omnipy(self) -> PyObject"""
        return _SALOMERuntime.RuntimeSALOME_get_omnipy(self)

RuntimeSALOME_swigregister = _SALOMERuntime.RuntimeSALOME_swigregister
RuntimeSALOME_swigregister(RuntimeSALOME)

def RuntimeSALOME_setRuntime(*args):
  """
    setRuntime(long flags = YACS::ENGINE::RuntimeSALOME::UsePython+YACS::ENGINE::RuntimeSALOME::UseCorba+YACS::ENGINE::RuntimeSALOME::UseXml+YACS::ENGINE::RuntimeSALOME::UseCpp+YACS::ENGINE::RuntimeSALOME::UseSalome)
    RuntimeSALOME_setRuntime()
    """
  return _SALOMERuntime.RuntimeSALOME_setRuntime(*args)

class SALOMEDispatcher(pilot.Dispatcher):
    """Proxy of C++ YACS::ENGINE::SALOMEDispatcher class"""
    __swig_setmethods__ = {}
    for _s in [pilot.Dispatcher]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SALOMEDispatcher, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.Dispatcher]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SALOMEDispatcher, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> SALOMEDispatcher"""
        this = _SALOMERuntime.new_SALOMEDispatcher()
        try: self.this.append(this)
        except: self.this = this
    def dispatch(self, *args):
        """dispatch(self, Node object, string event)"""
        return _SALOMERuntime.SALOMEDispatcher_dispatch(self, *args)

    def addObserver(self, *args):
        """addObserver(self, YACS_ORB::Observer_ptr observer, int numid, string event)"""
        return _SALOMERuntime.SALOMEDispatcher_addObserver(self, *args)

    def setSALOMEDispatcher():
        """setSALOMEDispatcher()"""
        return _SALOMERuntime.SALOMEDispatcher_setSALOMEDispatcher()

    if _newclass:setSALOMEDispatcher = staticmethod(setSALOMEDispatcher)
    __swig_getmethods__["setSALOMEDispatcher"] = lambda x: setSALOMEDispatcher
    def getSALOMEDispatcher():
        """getSALOMEDispatcher() -> SALOMEDispatcher"""
        return _SALOMERuntime.SALOMEDispatcher_getSALOMEDispatcher()

    if _newclass:getSALOMEDispatcher = staticmethod(getSALOMEDispatcher)
    __swig_getmethods__["getSALOMEDispatcher"] = lambda x: getSALOMEDispatcher
    __swig_destroy__ = _SALOMERuntime.delete_SALOMEDispatcher
    __del__ = lambda self : None;
SALOMEDispatcher_swigregister = _SALOMERuntime.SALOMEDispatcher_swigregister
SALOMEDispatcher_swigregister(SALOMEDispatcher)

def SALOMEDispatcher_setSALOMEDispatcher():
  """SALOMEDispatcher_setSALOMEDispatcher()"""
  return _SALOMERuntime.SALOMEDispatcher_setSALOMEDispatcher()

def SALOMEDispatcher_getSALOMEDispatcher():
  """SALOMEDispatcher_getSALOMEDispatcher() -> SALOMEDispatcher"""
  return _SALOMERuntime.SALOMEDispatcher_getSALOMEDispatcher()

class SalomeProc(pilot.Proc):
    """Proxy of C++ YACS::ENGINE::SalomeProc class"""
    __swig_setmethods__ = {}
    for _s in [pilot.Proc]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SalomeProc, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.Proc]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SalomeProc, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, string name) -> SalomeProc"""
        this = _SALOMERuntime.new_SalomeProc(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_SalomeProc
    __del__ = lambda self : None;
    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 _SALOMERuntime.SalomeProc_createInterfaceTc(self, *args)

    def createStructTc(self, *args):
        """createStructTc(self, string id, string name) -> TypeCode"""
        return _SALOMERuntime.SalomeProc_createStructTc(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.SalomeProc_typeName(self)

    def saveSchema(self, *args):
        """saveSchema(self, string xmlSchemaFile)"""
        return _SALOMERuntime.SalomeProc_saveSchema(self, *args)

    def getDefaultStudyId(self):
        """getDefaultStudyId(self) -> int"""
        return _SALOMERuntime.SalomeProc_getDefaultStudyId(self)

SalomeProc_swigregister = _SALOMERuntime.SalomeProc_swigregister
SalomeProc_swigregister(SalomeProc)

class PythonNode(pilot.InlineNode):
    """Proxy of C++ YACS::ENGINE::PythonNode class"""
    __swig_setmethods__ = {}
    for _s in [pilot.InlineNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PythonNode, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.InlineNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PythonNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _SALOMERuntime.delete_PythonNode
    __del__ = lambda self : None;
    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _SALOMERuntime.PythonNode_checkBasicConsistency(self)

    def execute(self):
        """execute(self)"""
        return _SALOMERuntime.PythonNode_execute(self)

    def load(self):
        """load(self)"""
        return _SALOMERuntime.PythonNode_load(self)

    def cloneNode(self, *args):
        """cloneNode(self, string name) -> PythonNode"""
        return _SALOMERuntime.PythonNode_cloneNode(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.PythonNode_typeName(self)

PythonNode_swigregister = _SALOMERuntime.PythonNode_swigregister
PythonNode_swigregister(PythonNode)
cvar = _SALOMERuntime.cvar
PythonNode.KIND = _SALOMERuntime.cvar.PythonNode_KIND
PythonNode.IMPL_NAME = _SALOMERuntime.cvar.PythonNode_IMPL_NAME

class PyFuncNode(pilot.InlineFuncNode):
    """Proxy of C++ YACS::ENGINE::PyFuncNode class"""
    __swig_setmethods__ = {}
    for _s in [pilot.InlineFuncNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PyFuncNode, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.InlineFuncNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PyFuncNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _SALOMERuntime.delete_PyFuncNode
    __del__ = lambda self : None;
    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _SALOMERuntime.PyFuncNode_checkBasicConsistency(self)

    def execute(self):
        """execute(self)"""
        return _SALOMERuntime.PyFuncNode_execute(self)

    def load(self):
        """load(self)"""
        return _SALOMERuntime.PyFuncNode_load(self)

    def loadRemote(self):
        """loadRemote(self)"""
        return _SALOMERuntime.PyFuncNode_loadRemote(self)

    def loadLocal(self):
        """loadLocal(self)"""
        return _SALOMERuntime.PyFuncNode_loadLocal(self)

    def executeRemote(self):
        """executeRemote(self)"""
        return _SALOMERuntime.PyFuncNode_executeRemote(self)

    def executeLocal(self):
        """executeLocal(self)"""
        return _SALOMERuntime.PyFuncNode_executeLocal(self)

    def getContainerLog(self):
        """getContainerLog(self) -> string"""
        return _SALOMERuntime.PyFuncNode_getContainerLog(self)

    def cloneNode(self, *args):
        """cloneNode(self, string name) -> PyFuncNode"""
        return _SALOMERuntime.PyFuncNode_cloneNode(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.PyFuncNode_typeName(self)

PyFuncNode_swigregister = _SALOMERuntime.PyFuncNode_swigregister
PyFuncNode_swigregister(PyFuncNode)

class InterpreterUnlocker(_object):
    """Proxy of C++ YACS::ENGINE::InterpreterUnlocker class"""
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InterpreterUnlocker, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InterpreterUnlocker, name)
    __repr__ = _swig_repr
    def __init__(self): 
        """__init__(self) -> InterpreterUnlocker"""
        this = _SALOMERuntime.new_InterpreterUnlocker()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_InterpreterUnlocker
    __del__ = lambda self : None;
InterpreterUnlocker_swigregister = _SALOMERuntime.InterpreterUnlocker_swigregister
InterpreterUnlocker_swigregister(InterpreterUnlocker)

class InputPyPort(pilot.InputPort):
    """Proxy of C++ YACS::ENGINE::InputPyPort class"""
    __swig_setmethods__ = {}
    for _s in [pilot.InputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputPyPort, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.InputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputPyPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> InputPyPort
        __init__(self, InputPyPort other, Node newHelder) -> InputPyPort
        """
        this = _SALOMERuntime.new_InputPyPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_InputPyPort
    __del__ = lambda self : None;
    def edIsManuallyInitialized(self):
        """edIsManuallyInitialized(self) -> bool"""
        return _SALOMERuntime.InputPyPort_edIsManuallyInitialized(self)

    def edRemoveManInit(self):
        """edRemoveManInit(self)"""
        return _SALOMERuntime.InputPyPort_edRemoveManInit(self)

    def put(self, *args):
        """
        put(self, void data)
        put(self, PyObject data)
        """
        return _SALOMERuntime.InputPyPort_put(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _SALOMERuntime.InputPyPort_clone(self, *args)

    def getPyObj(self):
        """getPyObj(self) -> PyObj"""
        return _SALOMERuntime.InputPyPort_getPyObj(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.InputPyPort_getAsString(self)

    def get(self):
        """get(self) -> void"""
        return _SALOMERuntime.InputPyPort_get(self)

    def isEmpty(self):
        """isEmpty(self) -> bool"""
        return _SALOMERuntime.InputPyPort_isEmpty(self)

    def exSaveInit(self):
        """exSaveInit(self)"""
        return _SALOMERuntime.InputPyPort_exSaveInit(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _SALOMERuntime.InputPyPort_exRestoreInit(self)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.InputPyPort_dump(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.InputPyPort_typeName(self)

    def valToStr(self):
        """valToStr(self) -> string"""
        return _SALOMERuntime.InputPyPort_valToStr(self)

    def valFromStr(self, *args):
        """valFromStr(self, string valstr)"""
        return _SALOMERuntime.InputPyPort_valFromStr(self, *args)

InputPyPort_swigregister = _SALOMERuntime.InputPyPort_swigregister
InputPyPort_swigregister(InputPyPort)

class OutputPyPort(pilot.OutputPort):
    """Proxy of C++ YACS::ENGINE::OutputPyPort class"""
    __swig_setmethods__ = {}
    for _s in [pilot.OutputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputPyPort, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.OutputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputPyPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> OutputPyPort
        __init__(self, OutputPyPort other, Node newHelder) -> OutputPyPort
        """
        this = _SALOMERuntime.new_OutputPyPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_OutputPyPort
    __del__ = lambda self : None;
    def put(self, *args):
        """
        put(self, void data)
        put(self, PyObject data)
        """
        return _SALOMERuntime.OutputPyPort_put(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputPort"""
        return _SALOMERuntime.OutputPyPort_clone(self, *args)

    def get(self):
        """get(self) -> PyObject"""
        return _SALOMERuntime.OutputPyPort_get(self)

    def getPyObj(self):
        """getPyObj(self) -> PyObj"""
        return _SALOMERuntime.OutputPyPort_getPyObj(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.OutputPyPort_getAsString(self)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.OutputPyPort_dump(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.OutputPyPort_typeName(self)

    def valToStr(self):
        """valToStr(self) -> string"""
        return _SALOMERuntime.OutputPyPort_valToStr(self)

    def valFromStr(self, *args):
        """valFromStr(self, string valstr)"""
        return _SALOMERuntime.OutputPyPort_valFromStr(self, *args)

OutputPyPort_swigregister = _SALOMERuntime.OutputPyPort_swigregister
OutputPyPort_swigregister(OutputPyPort)

class InputXmlPort(pilot.InputPort):
    """Proxy of C++ YACS::ENGINE::InputXmlPort class"""
    __swig_setmethods__ = {}
    for _s in [pilot.InputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputXmlPort, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.InputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputXmlPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> InputXmlPort
        __init__(self, InputXmlPort other, Node newHelder) -> InputXmlPort
        """
        this = _SALOMERuntime.new_InputXmlPort(*args)
        try: self.this.append(this)
        except: self.this = this
    def edIsManuallyInitialized(self):
        """edIsManuallyInitialized(self) -> bool"""
        return _SALOMERuntime.InputXmlPort_edIsManuallyInitialized(self)

    def edRemoveManInit(self):
        """edRemoveManInit(self)"""
        return _SALOMERuntime.InputXmlPort_edRemoveManInit(self)

    def put(self, *args):
        """
        put(self, void data)
        put(self, char data)
        """
        return _SALOMERuntime.InputXmlPort_put(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _SALOMERuntime.InputXmlPort_clone(self, *args)

    def getXml(self):
        """getXml(self) -> char"""
        return _SALOMERuntime.InputXmlPort_getXml(self)

    def get(self):
        """get(self) -> void"""
        return _SALOMERuntime.InputXmlPort_get(self)

    def isEmpty(self):
        """isEmpty(self) -> bool"""
        return _SALOMERuntime.InputXmlPort_isEmpty(self)

    def exSaveInit(self):
        """exSaveInit(self)"""
        return _SALOMERuntime.InputXmlPort_exSaveInit(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _SALOMERuntime.InputXmlPort_exRestoreInit(self)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.InputXmlPort_dump(self)

    def valToStr(self):
        """valToStr(self) -> string"""
        return _SALOMERuntime.InputXmlPort_valToStr(self)

    def valFromStr(self, *args):
        """valFromStr(self, string valstr)"""
        return _SALOMERuntime.InputXmlPort_valFromStr(self, *args)

    __swig_destroy__ = _SALOMERuntime.delete_InputXmlPort
    __del__ = lambda self : None;
InputXmlPort_swigregister = _SALOMERuntime.InputXmlPort_swigregister
InputXmlPort_swigregister(InputXmlPort)

class OutputXmlPort(pilot.OutputPort):
    """Proxy of C++ YACS::ENGINE::OutputXmlPort class"""
    __swig_setmethods__ = {}
    for _s in [pilot.OutputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputXmlPort, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.OutputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputXmlPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> OutputXmlPort
        __init__(self, OutputXmlPort other, Node newHelder) -> OutputXmlPort
        """
        this = _SALOMERuntime.new_OutputXmlPort(*args)
        try: self.this.append(this)
        except: self.this = this
    def put(self, *args):
        """
        put(self, void data)
        put(self, char data)
        """
        return _SALOMERuntime.OutputXmlPort_put(self, *args)

    def get(self):
        """get(self) -> char"""
        return _SALOMERuntime.OutputXmlPort_get(self)

    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputPort"""
        return _SALOMERuntime.OutputXmlPort_clone(self, *args)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.OutputXmlPort_dump(self)

    def valToStr(self):
        """valToStr(self) -> string"""
        return _SALOMERuntime.OutputXmlPort_valToStr(self)

    def valFromStr(self, *args):
        """valFromStr(self, string valstr)"""
        return _SALOMERuntime.OutputXmlPort_valFromStr(self, *args)

    __swig_destroy__ = _SALOMERuntime.delete_OutputXmlPort
    __del__ = lambda self : None;
OutputXmlPort_swigregister = _SALOMERuntime.OutputXmlPort_swigregister
OutputXmlPort_swigregister(OutputXmlPort)

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

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _SALOMERuntime.PresetNode_accept(self, *args)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _SALOMERuntime.PresetNode_checkBasicConsistency(self)

    def setData(self, *args):
        """setData(self, OutputPort port, string data)"""
        return _SALOMERuntime.PresetNode_setData(self, *args)

    def createOutputPort(self, *args):
        """createOutputPort(self, string outputPortName, TypeCode type) -> OutputPort"""
        return _SALOMERuntime.PresetNode_createOutputPort(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.PresetNode_typeName(self)

    __swig_destroy__ = _SALOMERuntime.delete_PresetNode
    __del__ = lambda self : None;
PresetNode_swigregister = _SALOMERuntime.PresetNode_swigregister
PresetNode_swigregister(PresetNode)
PresetNode.IMPL_NAME = _SALOMERuntime.cvar.PresetNode_IMPL_NAME

class OutputPresetPort(OutputXmlPort):
    """Proxy of C++ YACS::ENGINE::OutputPresetPort class"""
    __swig_setmethods__ = {}
    for _s in [OutputXmlPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputPresetPort, name, value)
    __swig_getmethods__ = {}
    for _s in [OutputXmlPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputPresetPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> OutputPresetPort
        __init__(self, OutputPresetPort other, Node newHelder) -> OutputPresetPort
        """
        this = _SALOMERuntime.new_OutputPresetPort(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputPort"""
        return _SALOMERuntime.OutputPresetPort_clone(self, *args)

    def setData(self, *args):
        """setData(self, string data)"""
        return _SALOMERuntime.OutputPresetPort_setData(self, *args)

    def getData(self):
        """getData(self) -> string"""
        return _SALOMERuntime.OutputPresetPort_getData(self)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _SALOMERuntime.OutputPresetPort_checkBasicConsistency(self)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.OutputPresetPort_dump(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.OutputPresetPort_getAsString(self)

    def getPyObj(self):
        """getPyObj(self) -> PyObject"""
        return _SALOMERuntime.OutputPresetPort_getPyObj(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.OutputPresetPort_typeName(self)

    def setDataPy(self, *args):
        """setDataPy(self, PyObject ob)"""
        return _SALOMERuntime.OutputPresetPort_setDataPy(self, *args)

    __swig_destroy__ = _SALOMERuntime.delete_OutputPresetPort
    __del__ = lambda self : None;
OutputPresetPort_swigregister = _SALOMERuntime.OutputPresetPort_swigregister
OutputPresetPort_swigregister(OutputPresetPort)

class InputPresetPort(InputXmlPort):
    """Proxy of C++ YACS::ENGINE::InputPresetPort class"""
    __swig_setmethods__ = {}
    for _s in [InputXmlPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputPresetPort, name, value)
    __swig_getmethods__ = {}
    for _s in [InputXmlPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputPresetPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> InputPresetPort
        __init__(self, InputPresetPort other, Node newHelder) -> InputPresetPort
        """
        this = _SALOMERuntime.new_InputPresetPort(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _SALOMERuntime.InputPresetPort_clone(self, *args)

    def setData(self, *args):
        """setData(self, string data)"""
        return _SALOMERuntime.InputPresetPort_setData(self, *args)

    def getData(self):
        """getData(self) -> string"""
        return _SALOMERuntime.InputPresetPort_getData(self)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.InputPresetPort_dump(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.InputPresetPort_getAsString(self)

    def getPyObj(self):
        """getPyObj(self) -> PyObject"""
        return _SALOMERuntime.InputPresetPort_getPyObj(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.InputPresetPort_typeName(self)

    __swig_destroy__ = _SALOMERuntime.delete_InputPresetPort
    __del__ = lambda self : None;
InputPresetPort_swigregister = _SALOMERuntime.InputPresetPort_swigregister
InputPresetPort_swigregister(InputPresetPort)

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

    def createNode(self, *args):
        """createNode(self, string name) -> ServiceNode"""
        return _SALOMERuntime.CORBANode_createNode(self, *args)

    def getKind(self):
        """getKind(self) -> string"""
        return _SALOMERuntime.CORBANode_getKind(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.CORBANode_typeName(self)

    __swig_destroy__ = _SALOMERuntime.delete_CORBANode
    __del__ = lambda self : None;
CORBANode_swigregister = _SALOMERuntime.CORBANode_swigregister
CORBANode_swigregister(CORBANode)
CORBANode.KIND = _SALOMERuntime.cvar.CORBANode_KIND
CORBANode.IMPL_NAME = _SALOMERuntime.cvar.CORBANode_IMPL_NAME

class SalomeNode(pilot.ServiceNode):
    """Proxy of C++ YACS::ENGINE::SalomeNode class"""
    __swig_setmethods__ = {}
    for _s in [pilot.ServiceNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SalomeNode, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.ServiceNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SalomeNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _SALOMERuntime.delete_SalomeNode
    __del__ = lambda self : None;
    def execute(self):
        """execute(self)"""
        return _SALOMERuntime.SalomeNode_execute(self)

    def createNode(self, *args):
        """createNode(self, string name) -> ServiceNode"""
        return _SALOMERuntime.SalomeNode_createNode(self, *args)

    def getKind(self):
        """getKind(self) -> string"""
        return _SALOMERuntime.SalomeNode_getKind(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.SalomeNode_typeName(self)

    def getContainerLog(self):
        """getContainerLog(self) -> string"""
        return _SALOMERuntime.SalomeNode_getContainerLog(self)

SalomeNode_swigregister = _SALOMERuntime.SalomeNode_swigregister
SalomeNode_swigregister(SalomeNode)
SalomeNode.KIND = _SALOMERuntime.cvar.SalomeNode_KIND

class InputCorbaPort(pilot.InputPort):
    """Proxy of C++ YACS::ENGINE::InputCorbaPort class"""
    __swig_setmethods__ = {}
    for _s in [pilot.InputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputCorbaPort, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.InputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputCorbaPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> InputCorbaPort
        __init__(self, InputCorbaPort other, Node newHelder) -> InputCorbaPort
        """
        this = _SALOMERuntime.new_InputCorbaPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_InputCorbaPort
    __del__ = lambda self : None;
    def edIsManuallyInitialized(self):
        """edIsManuallyInitialized(self) -> bool"""
        return _SALOMERuntime.InputCorbaPort_edIsManuallyInitialized(self)

    def edRemoveManInit(self):
        """edRemoveManInit(self)"""
        return _SALOMERuntime.InputCorbaPort_edRemoveManInit(self)

    def put(self, *args):
        """
        put(self, void data)
        put(self, CORBA::Any data)
        """
        return _SALOMERuntime.InputCorbaPort_put(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _SALOMERuntime.InputCorbaPort_clone(self, *args)

    def get(self):
        """get(self) -> void"""
        return _SALOMERuntime.InputCorbaPort_get(self)

    def isEmpty(self):
        """isEmpty(self) -> bool"""
        return _SALOMERuntime.InputCorbaPort_isEmpty(self)

    def getAny(self):
        """getAny(self) -> CORBA::Any"""
        return _SALOMERuntime.InputCorbaPort_getAny(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.InputCorbaPort_getAsString(self)

    def getPyObj(self):
        """getPyObj(self) -> PyObject"""
        return _SALOMERuntime.InputCorbaPort_getPyObj(self)

    def exSaveInit(self):
        """exSaveInit(self)"""
        return _SALOMERuntime.InputCorbaPort_exSaveInit(self)

    def exRestoreInit(self):
        """exRestoreInit(self)"""
        return _SALOMERuntime.InputCorbaPort_exRestoreInit(self)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.InputCorbaPort_dump(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.InputCorbaPort_typeName(self)

    def valToStr(self):
        """valToStr(self) -> string"""
        return _SALOMERuntime.InputCorbaPort_valToStr(self)

    def valFromStr(self, *args):
        """valFromStr(self, string valstr)"""
        return _SALOMERuntime.InputCorbaPort_valFromStr(self, *args)

InputCorbaPort_swigregister = _SALOMERuntime.InputCorbaPort_swigregister
InputCorbaPort_swigregister(InputCorbaPort)


def __lshift__(*args):
  """__lshift__(std::ostream os, OutputCorbaPort p) -> std::ostream"""
  return _SALOMERuntime.__lshift__(*args)
class OutputCorbaPort(pilot.OutputPort):
    """Proxy of C++ YACS::ENGINE::OutputCorbaPort class"""
    __swig_setmethods__ = {}
    for _s in [pilot.OutputPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputCorbaPort, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.OutputPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputCorbaPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> OutputCorbaPort
        __init__(self, OutputCorbaPort other, Node newHelder) -> OutputCorbaPort
        """
        this = _SALOMERuntime.new_OutputCorbaPort(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_OutputCorbaPort
    __del__ = lambda self : None;
    def put(self, *args):
        """
        put(self, void data)
        put(self, CORBA::Any data)
        """
        return _SALOMERuntime.OutputCorbaPort_put(self, *args)

    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputPort"""
        return _SALOMERuntime.OutputCorbaPort_clone(self, *args)

    def getAny(self):
        """getAny(self) -> CORBA::Any"""
        return _SALOMERuntime.OutputCorbaPort_getAny(self)

    def getAnyOut(self):
        """getAnyOut(self) -> CORBA::Any"""
        return _SALOMERuntime.OutputCorbaPort_getAnyOut(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.OutputCorbaPort_getAsString(self)

    def getPyObj(self):
        """getPyObj(self) -> PyObject"""
        return _SALOMERuntime.OutputCorbaPort_getPyObj(self)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.OutputCorbaPort_dump(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.OutputCorbaPort_typeName(self)

    def valToStr(self):
        """valToStr(self) -> string"""
        return _SALOMERuntime.OutputCorbaPort_valToStr(self)

    def valFromStr(self, *args):
        """valFromStr(self, string valstr)"""
        return _SALOMERuntime.OutputCorbaPort_valFromStr(self, *args)

OutputCorbaPort_swigregister = _SALOMERuntime.OutputCorbaPort_swigregister
OutputCorbaPort_swigregister(OutputCorbaPort)

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

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _SALOMERuntime.StudyInNode_accept(self, *args)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _SALOMERuntime.StudyInNode_checkBasicConsistency(self)

    def setData(self, *args):
        """setData(self, OutputPort port, string data)"""
        return _SALOMERuntime.StudyInNode_setData(self, *args)

    def createOutputPort(self, *args):
        """createOutputPort(self, string outputPortName, TypeCode type) -> OutputPort"""
        return _SALOMERuntime.StudyInNode_createOutputPort(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.StudyInNode_typeName(self)

    __swig_destroy__ = _SALOMERuntime.delete_StudyInNode
    __del__ = lambda self : None;
StudyInNode_swigregister = _SALOMERuntime.StudyInNode_swigregister
StudyInNode_swigregister(StudyInNode)
StudyInNode.IMPL_NAME = _SALOMERuntime.cvar.StudyInNode_IMPL_NAME

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

    def accept(self, *args):
        """accept(self, Visitor visitor)"""
        return _SALOMERuntime.StudyOutNode_accept(self, *args)

    def checkBasicConsistency(self):
        """checkBasicConsistency(self)"""
        return _SALOMERuntime.StudyOutNode_checkBasicConsistency(self)

    def setData(self, *args):
        """setData(self, InputPort port, string data)"""
        return _SALOMERuntime.StudyOutNode_setData(self, *args)

    def createInputPort(self, *args):
        """createInputPort(self, string inputPortName, TypeCode type) -> InputPort"""
        return _SALOMERuntime.StudyOutNode_createInputPort(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.StudyOutNode_typeName(self)

    __swig_destroy__ = _SALOMERuntime.delete_StudyOutNode
    __del__ = lambda self : None;
StudyOutNode_swigregister = _SALOMERuntime.StudyOutNode_swigregister
StudyOutNode_swigregister(StudyOutNode)
StudyOutNode.IMPL_NAME = _SALOMERuntime.cvar.StudyOutNode_IMPL_NAME

class OutputStudyPort(OutputXmlPort):
    """Proxy of C++ YACS::ENGINE::OutputStudyPort class"""
    __swig_setmethods__ = {}
    for _s in [OutputXmlPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, OutputStudyPort, name, value)
    __swig_getmethods__ = {}
    for _s in [OutputXmlPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, OutputStudyPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> OutputStudyPort
        __init__(self, OutputStudyPort other, Node newHelder) -> OutputStudyPort
        """
        this = _SALOMERuntime.new_OutputStudyPort(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self, *args):
        """clone(self, Node newHelder) -> OutputPort"""
        return _SALOMERuntime.OutputStudyPort_clone(self, *args)

    def setData(self, *args):
        """setData(self, string data)"""
        return _SALOMERuntime.OutputStudyPort_setData(self, *args)

    def getData(self):
        """getData(self) -> string"""
        return _SALOMERuntime.OutputStudyPort_getData(self)

    def putIOR(self, *args):
        """putIOR(self, string ior)"""
        return _SALOMERuntime.OutputStudyPort_putIOR(self, *args)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.OutputStudyPort_dump(self)

    def getPyObj(self):
        """getPyObj(self) -> string"""
        return _SALOMERuntime.OutputStudyPort_getPyObj(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.OutputStudyPort_getAsString(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.OutputStudyPort_typeName(self)

    def getDataFromStudy(self, *args):
        """getDataFromStudy(self, SALOMEDS::Study_var myStudy)"""
        return _SALOMERuntime.OutputStudyPort_getDataFromStudy(self, *args)

    __swig_destroy__ = _SALOMERuntime.delete_OutputStudyPort
    __del__ = lambda self : None;
OutputStudyPort_swigregister = _SALOMERuntime.OutputStudyPort_swigregister
OutputStudyPort_swigregister(OutputStudyPort)

class InputStudyPort(InputXmlPort):
    """Proxy of C++ YACS::ENGINE::InputStudyPort class"""
    __swig_setmethods__ = {}
    for _s in [InputXmlPort]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, InputStudyPort, name, value)
    __swig_getmethods__ = {}
    for _s in [InputXmlPort]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, InputStudyPort, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, Node node, TypeCode type) -> InputStudyPort
        __init__(self, InputStudyPort other, Node newHelder) -> InputStudyPort
        """
        this = _SALOMERuntime.new_InputStudyPort(*args)
        try: self.this.append(this)
        except: self.this = this
    def clone(self, *args):
        """clone(self, Node newHelder) -> InputPort"""
        return _SALOMERuntime.InputStudyPort_clone(self, *args)

    def setData(self, *args):
        """setData(self, string data)"""
        return _SALOMERuntime.InputStudyPort_setData(self, *args)

    def getData(self):
        """getData(self) -> string"""
        return _SALOMERuntime.InputStudyPort_getData(self)

    def getIOR(self):
        """getIOR(self) -> string"""
        return _SALOMERuntime.InputStudyPort_getIOR(self)

    def splitXML(self, *args):
        """splitXML(self, string s) -> string"""
        return _SALOMERuntime.InputStudyPort_splitXML(self, *args)

    def dump(self):
        """dump(self) -> string"""
        return _SALOMERuntime.InputStudyPort_dump(self)

    def getPyObj(self):
        """getPyObj(self) -> string"""
        return _SALOMERuntime.InputStudyPort_getPyObj(self)

    def getAsString(self):
        """getAsString(self) -> string"""
        return _SALOMERuntime.InputStudyPort_getAsString(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.InputStudyPort_typeName(self)

    def putDataInStudy(self, *args):
        """putDataInStudy(self, SALOMEDS::Study_var myStudy, SALOMEDS::StudyBuilder_var aBuilder)"""
        return _SALOMERuntime.InputStudyPort_putDataInStudy(self, *args)

    __swig_destroy__ = _SALOMERuntime.delete_InputStudyPort
    __del__ = lambda self : None;
InputStudyPort_swigregister = _SALOMERuntime.InputStudyPort_swigregister
InputStudyPort_swigregister(InputStudyPort)

class SalomeOptimizerAlgStandardized(pilot.OptimizerAlgStandardized):
    """Proxy of C++ YACS::ENGINE::SalomeOptimizerAlgStandardized class"""
    __swig_setmethods__ = {}
    for _s in [pilot.OptimizerAlgStandardized]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SalomeOptimizerAlgStandardized, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.OptimizerAlgStandardized]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SalomeOptimizerAlgStandardized, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """__init__(self, Pool pool, OptimizerAlgBase alg) -> SalomeOptimizerAlgStandardized"""
        this = _SALOMERuntime.new_SalomeOptimizerAlgStandardized(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_SalomeOptimizerAlgStandardized
    __del__ = lambda self : None;
    def parseFileToInit(self, *args):
        """parseFileToInit(self, string fileName)"""
        return _SALOMERuntime.SalomeOptimizerAlgStandardized_parseFileToInit(self, *args)

    def start(self):
        """start(self)"""
        return _SALOMERuntime.SalomeOptimizerAlgStandardized_start(self)

    def takeDecision(self):
        """takeDecision(self)"""
        return _SALOMERuntime.SalomeOptimizerAlgStandardized_takeDecision(self)

    def getTCForIn(self):
        """getTCForIn(self) -> TypeCode"""
        return _SALOMERuntime.SalomeOptimizerAlgStandardized_getTCForIn(self)

    def getTCForOut(self):
        """getTCForOut(self) -> TypeCode"""
        return _SALOMERuntime.SalomeOptimizerAlgStandardized_getTCForOut(self)

    def initialize(self, *args):
        """initialize(self, Any input)"""
        return _SALOMERuntime.SalomeOptimizerAlgStandardized_initialize(self, *args)

    def finish(self):
        """finish(self)"""
        return _SALOMERuntime.SalomeOptimizerAlgStandardized_finish(self)

SalomeOptimizerAlgStandardized_swigregister = _SALOMERuntime.SalomeOptimizerAlgStandardized_swigregister
SalomeOptimizerAlgStandardized_swigregister(SalomeOptimizerAlgStandardized)

class SalomeOptimizerLoop(pilot.OptimizerLoop):
    """Proxy of C++ YACS::ENGINE::SalomeOptimizerLoop class"""
    __swig_setmethods__ = {}
    for _s in [pilot.OptimizerLoop]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SalomeOptimizerLoop, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.OptimizerLoop]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SalomeOptimizerLoop, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        """
        __init__(self, string name, string algLibWthOutExt, string symbolNameToOptimizerAlgBaseInstanceFactory, 
            bool algInitOnFile, 
            bool initAlgo = True) -> SalomeOptimizerLoop
        __init__(self, string name, string algLibWthOutExt, string symbolNameToOptimizerAlgBaseInstanceFactory, 
            bool algInitOnFile) -> SalomeOptimizerLoop
        __init__(self, SalomeOptimizerLoop other, ComposedNode father, bool editionOnly) -> SalomeOptimizerLoop
        """
        this = _SALOMERuntime.new_SalomeOptimizerLoop(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _SALOMERuntime.delete_SalomeOptimizerLoop
    __del__ = lambda self : None;
    def setAlgorithm(self, *args):
        """
        setAlgorithm(self, string alglib, string symbol, bool checkLinks = True)
        setAlgorithm(self, string alglib, string symbol)
        """
        return _SALOMERuntime.SalomeOptimizerLoop_setAlgorithm(self, *args)

    def getAlgLib(self):
        """getAlgLib(self) -> string"""
        return _SALOMERuntime.SalomeOptimizerLoop_getAlgLib(self)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.SalomeOptimizerLoop_typeName(self)

SalomeOptimizerLoop_swigregister = _SALOMERuntime.SalomeOptimizerLoop_swigregister
SalomeOptimizerLoop_swigregister(SalomeOptimizerLoop)

class DistributedPythonNode(pilot.ServerNode):
    """Proxy of C++ YACS::ENGINE::DistributedPythonNode class"""
    __swig_setmethods__ = {}
    for _s in [pilot.ServerNode]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DistributedPythonNode, name, value)
    __swig_getmethods__ = {}
    for _s in [pilot.ServerNode]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DistributedPythonNode, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _SALOMERuntime.delete_DistributedPythonNode
    __del__ = lambda self : None;
    def execute(self):
        """execute(self)"""
        return _SALOMERuntime.DistributedPythonNode_execute(self)

    def load(self):
        """load(self)"""
        return _SALOMERuntime.DistributedPythonNode_load(self)

    def getEffectiveKindOfServer(self):
        """getEffectiveKindOfServer(self) -> string"""
        return _SALOMERuntime.DistributedPythonNode_getEffectiveKindOfServer(self)

    def getKind(self):
        """getKind(self) -> string"""
        return _SALOMERuntime.DistributedPythonNode_getKind(self)

    def createNode(self, *args):
        """createNode(self, string name) -> ServerNode"""
        return _SALOMERuntime.DistributedPythonNode_createNode(self, *args)

    def typeName(self):
        """typeName(self) -> string"""
        return _SALOMERuntime.DistributedPythonNode_typeName(self)

DistributedPythonNode_swigregister = _SALOMERuntime.DistributedPythonNode_swigregister
DistributedPythonNode_swigregister(DistributedPythonNode)
DistributedPythonNode.KIND = _SALOMERuntime.cvar.DistributedPythonNode_KIND
DistributedPythonNode.IMPL_NAME = _SALOMERuntime.cvar.DistributedPythonNode_IMPL_NAME
DistributedPythonNode.SALOME_CONTAINER_METHOD_IDL = _SALOMERuntime.cvar.DistributedPythonNode_SALOME_CONTAINER_METHOD_IDL



