YACS::ENGINE::RuntimeSALOME Class Reference

#include <RuntimeSALOME.hxx>

Inheritance diagram for YACS::ENGINE::RuntimeSALOME:

Collaboration diagram for YACS::ENGINE::RuntimeSALOME:

Public Types
enum	{   IsPyExt = 1 , UsePython = 2 , UseCorba = 4 , UseXml = 8 ,   UseCpp = 16 , UseSalome = 32 }

Public Member Functions
std::unique_ptr< SALOME_NamingService_Container_Abstract >	getNS ()
virtual std::string	getVersion () const
virtual void	init (long flags, int argc, char *argv[])
	CORBA and Python initialization. More...
virtual void	fini (bool isFinalizingPython=true)
PyObject *	launchSubProcess (const std::vector< std::string > &cmds)
virtual std::vector< std::pair< std::string, int > >	getCatalogOfComputeNodes () const
virtual InputPort *	createInputPort (const std::string &name, const std::string &impl, Node *node, TypeCode *type)
virtual OutputPort *	createOutputPort (const std::string &name, const std::string &impl, Node *node, TypeCode *type)
virtual InputDataStreamPort *	createInputDataStreamPort (const std::string &name, Node *node, TypeCode *type)
virtual OutputDataStreamPort *	createOutputDataStreamPort (const std::string &name, Node *node, TypeCode *type)
virtual DataNode *	createInDataNode (const std::string &kind, const std::string &name)
virtual DataNode *	createOutDataNode (const std::string &kind, const std::string &name)
virtual InlineFuncNode *	createFuncNode (const std::string &kind, const std::string &name)
virtual InlineNode *	createScriptNode (const std::string &kind, const std::string &name)
virtual ServiceNode *	createRefNode (const std::string &kind, const std::string &name)
virtual ServiceNode *	createCompoNode (const std::string &kind, const std::string &name)
virtual ServiceInlineNode *	createSInlineNode (const std::string &kind, const std::string &name)
virtual ComponentInstance *	createComponentInstance (const std::string &name, const std::string &kind="")
virtual Container *	createContainer (const std::string &kind="")
virtual WhileLoop *	createWhileLoop (const std::string &name)
virtual ForLoop *	createForLoop (const std::string &name)
virtual OptimizerLoop *	createOptimizerLoop (const std::string &name, const std::string &algLib, const std::string &factoryName, bool algInitOnFile, const std::string &kind="", Proc *procForTypes=NULL)
virtual Bloc *	createBloc (const std::string &name)
virtual Proc *	createProc (const std::string &name)
virtual TypeCode *	createInterfaceTc (const std::string &id, const std::string &name, std::list< TypeCodeObjref * > ltc)
virtual TypeCode *	createSequenceTc (const std::string &id, const std::string &name, TypeCode *content)
virtual TypeCodeStruct *	createStructTc (const std::string &id, const std::string &name)
virtual InputPort *	adapt (InputPort *source, const std::string &impl, TypeCode *type, bool init=false)
	Main adapter function : adapt an InputPort to be able to connect it to an OutputPort with a possible different implementation. More...
virtual InputPort *	adapt (InPropertyPort *source, const std::string &impl, TypeCode *type, bool init=false)
	Adapter function for InPropertyPort. More...
virtual InputPort *	adaptNeutral (InputPort *source, const std::string &impl, TypeCode *type, bool init)
	Adapt a Neutral input port to connect it to an output port with a given implementation. More...
virtual InputPort *	adapt (InputCorbaPort *source, const std::string &impl, TypeCode *type, bool init)
	Adapt a CORBA input port to an output which implementation and type are given by impl and type. More...
virtual InputPort *	adaptCorbaToCorba (InputCorbaPort *source, TypeCode *type)
	Adapt a CORBA input port to a CORBA output port. More...
virtual InputPort *	adaptCorbaToNeutral (InputCorbaPort *source, TypeCode *type)
	Adapt a CORBA input port to a neutral data. More...
virtual InputPort *	adaptCorbaToPython (InputCorbaPort *source, TypeCode *type)
	Adapt a CORBA input port to a Python output port. More...
virtual InputPort *	adaptCorbaToCpp (InputCorbaPort *source, TypeCode *type)
	Adapt a CORBA input port to a C++ output port. More...
virtual InputPort *	adaptCorbaToXml (InputCorbaPort *source, TypeCode *type)
	Adapt a CORBA input port to connect it to a XML output port. More...
virtual InputPort *	adapt (InputPyPort *source, const std::string &impl, TypeCode *type, bool init)
	Adapt a Python input port to an output port with a given implementation. More...
virtual InputPort *	adaptPythonToCorba (InputPyPort *source, TypeCode *type)
	Adapt a Python input port to a Corba output port. More...
virtual InputPort *	adaptPythonToNeutral (InputPyPort *source, TypeCode *type)
	Adapt a Python input port to a Neutral data port. More...
virtual InputPort *	adaptPythonToPython (InputPyPort *source, TypeCode *type, bool init)
	Adapt a Python input port to a Python output port. More...
virtual InputPort *	adaptPythonToXml (InputPyPort *source, TypeCode *type)
	Adapt a Python input port to a Xml output port. More...
virtual InputPort *	adaptPythonToCpp (InputPyPort *source, TypeCode *type)
	Adapt a Python input port to a C++ output port. More...
virtual InputPort *	adapt (InputCppPort *source, const std::string &impl, TypeCode *type, bool init)
	Adapt a C++ input port to connect it to an output port with a given implementation. More...
virtual InputPort *	adaptCppToCorba (InputCppPort *source, TypeCode *type)
	Adapt a C++ input port to connect it to a CORBA output port. More...
virtual InputPort *	adaptCppToNeutral (InputCppPort *source, TypeCode *type)
	Adapt a C++ input port to a Neutral output port. More...
virtual InputPort *	adaptCppToPython (InputCppPort *source, TypeCode *type)
	Adapt a C++ input port to a Python output port. More...
virtual InputPort *	adaptCppToXml (InputCppPort *source, TypeCode *type)
virtual InputPort *	adaptCppToCpp (InputCppPort *source, TypeCode *type)
	Adapt a C++ input port to a C++ output port. More...
virtual InputPort *	adapt (InputXmlPort *source, const std::string &impl, TypeCode *type, bool init)
	Adapt an Xml input port to an output port which implementation is given by impl. More...
virtual InputPort *	adaptXmlToCorba (InputXmlPort *source, TypeCode *type)
	Adapt a XML input port to connect it to a CORBA output port. More...
virtual InputPort *	adaptXmlToPython (InputXmlPort *inport, TypeCode *type)
	Adapt a XML input port to a Python output port. More...
virtual InputPort *	adaptXmlToCpp (InputXmlPort *inport, TypeCode *type)
	Adapt a XML input port to a C++ output port. More...
virtual InputPort *	adaptXmlToNeutral (InputXmlPort *inport, TypeCode *type)
	Adapt a XML input port to a Neutral output port. More...
virtual InputPort *	adaptXmlToXml (InputXmlPort *inport, TypeCode *type, bool init)
	Adapt a XML input port to a Xml output port. More...
virtual InputPort *	adaptNeutralToXml (InputPort *inport, TypeCode *type)
	Adapt a Neutral input port to a Xml output port. More...
virtual InputPort *	adaptNeutralToPython (InputPort *inport, TypeCode *type)
	Adapt a Neutral input port to a Python output port. More...
virtual InputPort *	adaptNeutralToCorba (InputPort *inport, TypeCode *type)
	Adapt a Neutral input port to a Corba output port. More...
virtual InputPort *	adaptNeutralToCpp (InputPort *inport, TypeCode *type)
	Adapt a Neutral input port to a C++ output port. More...
virtual void *	convertNeutral (TypeCode *type, Any *data)
	Convert a YACS::ENGINE::Any object to an external object with type type. More...
virtual std::string	convertNeutralAsString (TypeCode *type, Any *data)
	Convert a YACS::ENGINE::Any object to a string to be used in GUI for example. More...
virtual std::string	convertPyObjectToString (PyObject *ob)
virtual PyObject *	convertStringToPyObject (const std::string &s)
virtual	~RuntimeSALOME ()
void	loadModulCatalog ()
CORBA::ORB_ptr	getOrb () const
CORBA::Object_var	getFromNS (const char *entry) const
PyObject *	getPyOrb () const
PyObject *	getBuiltins () const
DynamicAny::DynAnyFactory_ptr	getDynFactory () const
omniORBpyAPI *	getApi ()
PyObject *	get_omnipy ()
ConnectionManager &	getConnectionManager ()
Public Member Functions inherited from YACS::ENGINE::Runtime
virtual void	init ()
virtual void	fini ()
virtual Catalog *	loadCatalog (const std::string &sourceKind, const std::string &path)
	Load a catalog of calculation to use as factory. More...
virtual ForEachLoop *	createForEachLoop (const std::string &name, TypeCode *type)
virtual ForEachLoopDyn *	createForEachLoopDyn (const std::string &name, TypeCode *type)
virtual Switch *	createSwitch (const std::string &name)
virtual void	removeRuntime ()
virtual	~Runtime ()
virtual void	setCatalogLoaderFactory (const std::string &name, CatalogLoader *factory)
	Add a catalog loader factory to the map _catalogLoaderFactoryMap under the name name. More...
Catalog *	getBuiltinCatalog ()
	Get the catalog of base nodes (elementary and composed) More...
virtual void	addCatalog (Catalog *catalog)
	Add a catalog of types and nodes to the runtime. More...
virtual TypeCode *	getTypeCode (const std::string &name)
	Get a typecode by its name from runtime catalogs. More...

Static Public Member Functions
static void	setRuntime (long flags=UsePython+UseCorba+UseXml+UseCpp+UseSalome, int argc=0, char *argv[]=NULL)

Public Attributes
enum YACS::ENGINE::RuntimeSALOME:: { ... }	FLAGS
Public Attributes inherited from YACS::ENGINE::Runtime
std::map< std::string, CatalogLoader * >	_catalogLoaderFactoryMap

Protected Member Functions
	RuntimeSALOME ()
	RuntimeSALOME (long flags, int argc, char *argv[])
void	initBuiltins ()
Protected Member Functions inherited from YACS::ENGINE::Runtime
	Runtime ()

Protected Attributes
CORBA::ORB_var	_orb
PyObject *	_pyorb
PyObject *	_bltins
DynamicAny::DynAnyFactory_var	_dynFactory
omniORBpyAPI *	_api
PyObject *	_omnipy
long	_flags
bool	_usePython
bool	_useCorba
bool	_useCpp
bool	_useXml
Protected Attributes inherited from YACS::ENGINE::Runtime
std::set< std::string >	_setOfImplementation
Catalog *	_builtinCatalog
std::vector< Catalog * >	_catalogs

Static Private Member Functions
static Runtime *	getSingleton ()

Private Attributes
ConnectionManager	_connectionManager

Friends
RuntimeSALOME *	getSALOMERuntime ()

Additional Inherited Members
Static Public Attributes inherited from YACS::ENGINE::Runtime
static const char	RUNTIME_ENGINE_INTERACTION_IMPL_NAME [] ="Neutral"
static YACS::ENGINE::TypeCode *	_tc_double = 0
static YACS::ENGINE::TypeCode *	_tc_int = 0
static YACS::ENGINE::TypeCode *	_tc_bool = 0
static YACS::ENGINE::TypeCode *	_tc_string = 0
static YACS::ENGINE::TypeCode *	_tc_file = 0
static YACS::ENGINE::TypeCode *	_tc_stringpair = 0
static YACS::ENGINE::TypeCode *	_tc_propvec = 0
Static Protected Attributes inherited from YACS::ENGINE::Runtime
static Runtime *	_singleton = 0

Detailed Description

Definition at line 58 of file RuntimeSALOME.hxx.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
IsPyExt
UsePython
UseCorba
UseXml
UseCpp
UseSalome

Definition at line 64 of file RuntimeSALOME.hxx.

      {
        IsPyExt = 1,
        UsePython = 2,
        UseCorba = 4,
        UseXml = 8,
        UseCpp = 16,
        UseSalome = 32
      } FLAGS;

Constructor & Destructor Documentation

~RuntimeSALOME()

RuntimeSALOME::~RuntimeSALOME ( )

virtual

Definition at line 244 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::~RuntimeSALOME");
  // destroy catalog loader prototypes
  std::map<std::string, CatalogLoader*>::const_iterator pt;
  for(pt=_catalogLoaderFactoryMap.begin();pt!=_catalogLoaderFactoryMap.end();pt++)
    {
      delete (*pt).second;
    }
  _connectionManager.ShutdownWithExit();
}

References DEBTRACE.

RuntimeSALOME() [1/2]

RuntimeSALOME::RuntimeSALOME ( )

protected

Singleton creation, initialize converter map

Definition at line 165 of file RuntimeSALOME.cxx.

{
  YASSERT(0);
}

References YASSERT.

RuntimeSALOME() [2/2]

RuntimeSALOME::RuntimeSALOME ( long  flags, int  argc, char *  argv[]  )

protected

Definition at line 214 of file RuntimeSALOME.cxx.

{
  // If all flags (apart the IsPyExt flags) are unset, force them to true
  if ((flags - flags & RuntimeSALOME::IsPyExt) == 0)
    flags += RuntimeSALOME::UseCorba + RuntimeSALOME::UsePython
          +  RuntimeSALOME::UseCpp + RuntimeSALOME::UseXml;
 
  // Salome Nodes implies Corba Nodes
  if (flags & RuntimeSALOME::UseSalome)
    flags |= RuntimeSALOME::UseCorba;
 
  // Corba Nodes implies Python Nodes
  if (flags & RuntimeSALOME::UseCorba)
    flags |= RuntimeSALOME::UsePython;
 
  _useCorba = flags & RuntimeSALOME::UseCorba;
  _usePython = flags & RuntimeSALOME::UsePython;
  _useCpp = flags & RuntimeSALOME::UseCpp;
  _useXml = flags & RuntimeSALOME::UseXml;
 
  /* Init libxml */
  xmlInitParser();
 
  if (_useCpp)    _setOfImplementation.insert(CppNode::IMPL_NAME);
  if (_usePython) _setOfImplementation.insert(PythonNode::IMPL_NAME);
  if (_useCorba)  _setOfImplementation.insert(CORBANode::IMPL_NAME);
  if (_useXml)    _setOfImplementation.insert(XmlNode::IMPL_NAME);
  init(flags, argc, argv);
}

Member Function Documentation

adapt() [1/6]

InputPort * RuntimeSALOME::adapt ( InPropertyPort *  source, const std::string &  impl, TypeCode *  type, bool  init = false  )

virtual

Adapter function for InPropertyPort.

Parameters

source	: InPropertyPort to be adapted
impl	: new implementation (C++, python, CORBA, XML, Neutral)
type	: data type provided by the InPropertyPort
init	: indicates if the adapted InPropertyPort will be used for initialization (value true) or not (value false)

Returns

: adapted InputPort

Implements YACS::ENGINE::Runtime.

Definition at line 892 of file RuntimeSALOME.cxx.

{
  return adaptNeutral((InputPort *)source,impl,type,init);
}

adapt() [2/6]

InputPort * RuntimeSALOME::adapt ( InputCorbaPort *  source, const std::string &  impl, TypeCode *  type, bool  init  )

virtual

Adapt a CORBA input port to an output which implementation and type are given by impl and type.

Parameters

source	: input port to adapt to implementation impl and type type
impl	: output port implementation (C++, Python or Corba)
type	: outport data type
init	: if init is true the proxy port will be used in initialization of input port (needs value check)

Returns

an adaptator port which type depends on impl

Definition at line 1437 of file RuntimeSALOME.cxx.

{
  if(impl == CppNode::IMPL_NAME)
    {
      return adaptCorbaToCpp(source,type);
    }
  else if(impl == PythonNode::IMPL_NAME)
    {
      return adaptCorbaToPython(source,type);
    }
  else if(impl == CORBANode::IMPL_NAME)
    {
      if(init)
        return adaptCorbaToCorba(source,type);
      else
        return adaptCorbaToCorba(source,type);
    }
  else if(impl == XmlNode::IMPL_NAME )
    {
      return adaptCorbaToXml(source,type);
    }
  else if(impl == Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME)
    {
      return adaptCorbaToNeutral(source,type);
    }
  else
    {
      stringstream msg;
      msg << "Cannot connect InputCorbaPort : unknown implementation " ;
      msg << __FILE__ << ":" <<__LINE__;
      throw ConversionException(msg.str());
    }
}

adapt() [3/6]

InputPort * RuntimeSALOME::adapt ( InputCppPort *  source, const std::string &  impl, TypeCode *  type, bool  init  )

virtual

Adapt a C++ input port to connect it to an output port with a given implementation.

Parameters

source	: input port to adapt to implementation impl and type type
impl	: output port implementation (C++, Python or Corba)
type	: output port supported type
init	: if init is true the proxy port will be used in initialization of input port (needs value check)

Returns

the adaptated port

Definition at line 1868 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adapt(InputCppPort* source)");
  if(impl == CORBANode::IMPL_NAME)
    {
      return adaptCppToCorba(source,type);
    }
  else if(impl == PythonNode::IMPL_NAME)
    {
      return adaptCppToPython(source,type);
    }
  else if(impl == XmlNode::IMPL_NAME)
    {
      return adaptCppToXml(source,type);
    }
  else if(impl == CppNode::IMPL_NAME)
    {
      return adaptCppToCpp(source, type);
    }
  else if(impl == Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME)
    {
      return adaptCppToNeutral(source, type);
    }
  else
    {
      stringstream msg;
      msg << "Cannot connect InputCppPort to " << impl << " implementation";
      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
      throw ConversionException(msg.str());
    }
}

References DEBTRACE.

adapt() [4/6]

InputPort * RuntimeSALOME::adapt ( InputPort *  source, const std::string &  impl, TypeCode *  type, bool  init = false  )

virtual

Main adapter function : adapt an InputPort to be able to connect it to an OutputPort with a possible different implementation.

Parameters

source	: InputPort to be adapted
impl	: new implementation (C++, python, CORBA, XML, Neutral)
type	: data type provided by the InputPort
init	: indicates if the adapted InputPort will be used for initialization (value true) or not (value false)

Returns

: adapted InputPort

Implements YACS::ENGINE::Runtime.

Definition at line 849 of file RuntimeSALOME.cxx.

{
  string imp_source=source->getNode()->getImplementation();
  if(imp_source == PythonNode::IMPL_NAME)
    {
      return adapt((InputPyPort*)source,impl,type,init);
    }
  else if(imp_source == CppNode::IMPL_NAME)
    {
      return adapt((InputCppPort*)source,impl,type,init);
    }
  else if(imp_source == CORBANode::IMPL_NAME)
    {
      return adapt((InputCorbaPort*)source,impl,type,init);
    }
  else if(imp_source == XmlNode::IMPL_NAME)
    {
      return adapt((InputXmlPort*)source,impl,type,init);
    }
  else if(imp_source == Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME)
    {
      return adaptNeutral(source,impl,type,init);
    }
  else
    {
      stringstream msg;
      msg << "Cannot adapt " << imp_source << " InputPort to " << impl;
      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
      throw ConversionException(msg.str());
    }
}

References gui.adapt::adapt(), YACS::ENGINE::Node::getImplementation(), and YACS::ENGINE::Port::getNode().

adapt() [5/6]

InputPort * RuntimeSALOME::adapt ( InputPyPort *  source, const std::string &  impl, TypeCode *  type, bool  init  )

virtual

Adapt a Python input port to an output port with a given implementation.

Parameters

source	: input port to adapt to implementation impl and type type
impl	: output port implementation (C++, Python or Corba)
type	: output port type
init	: if init is true the proxy port will be used in initialization of input port (needs value check)

Returns

adaptated input port

Definition at line 1703 of file RuntimeSALOME.cxx.

{
  if(impl == CppNode::IMPL_NAME)
    {
      return adaptPythonToCpp(source,type);
    }
  else if(impl == PythonNode::IMPL_NAME)
    {
      return adaptPythonToPython(source,type,init);
    }
  else if(impl == CORBANode::IMPL_NAME)
    {
      return adaptPythonToCorba(source,type);
    }
  else if(impl == Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME)
    {
      return adaptPythonToNeutral(source,type);
    }
  else if(impl == XmlNode::IMPL_NAME)
    {
      return adaptPythonToXml(source,type);
    }
  else
    {
      stringstream msg;
      msg << "Cannot connect InputPyPort : unknown implementation " << impl;
      msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
      throw ConversionException(msg.str());
    }
}

adapt() [6/6]

InputPort * RuntimeSALOME::adapt ( InputXmlPort *  source, const std::string &  impl, TypeCode *  type, bool  init  )

virtual

Adapt an Xml input port to an output port which implementation is given by impl.

Parameters

source	: input port to adapt to implementation impl and type type
impl	: output port implementation (C++, Python or Corba)
type	: output port supported type
init	: if init is true the proxy port will be used in initialization of input port (needs value check)

Returns

the adaptated port

Definition at line 1175 of file RuntimeSALOME.cxx.

{
  if(impl == CORBANode::IMPL_NAME)
    {
      return adaptXmlToCorba(source,type);
    }
  else if(impl == PythonNode::IMPL_NAME)
    {
      return adaptXmlToPython(source,type);
    }
  else if(impl == CppNode::IMPL_NAME)
    {
      return adaptXmlToCpp(source,type);
    }
  else if(impl == XmlNode::IMPL_NAME )
    {
      return adaptXmlToXml(source,type,init);
    }
  else if(impl == Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME)
    {
      return adaptXmlToNeutral(source,type);
    }
  else
    {
      stringstream msg;
      msg << "Cannot connect InputXmlPort to " << impl << " implementation";
      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
      throw ConversionException(msg.str());
    }
}

adaptCorbaToCorba()

InputPort * RuntimeSALOME::adaptCorbaToCorba ( InputCorbaPort *  inport, TypeCode *  type  )

virtual

Adapt a CORBA input port to a CORBA output port.

Parameters

inport	: input port to adapt to CORBA outport data type
type	: outport data type

Returns

an adaptator port of type InputCORBAPort

Definition at line 1215 of file RuntimeSALOME.cxx.

{
  if(type->isA(inport->edGetType()))
    {
      //types are compatible : no conversion 
      //outport data type is more specific than inport required type
      //so the inport can be used safely 
      return new ProxyPort(inport);
    }
  else if(isAdaptableCorbaCorba(type,inport->edGetType()))
    {
      //ouport data can be converted to inport data type
      return new CorbaCorba(inport);
    }
  //outport data can not be converted
  stringstream msg;
  msg << "Cannot connect Corba output port with type: " << type->id() ;
  msg << " to CORBA input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::TypeCode::isA(), and YACS::ENGINE::isAdaptableCorbaCorba().

adaptCorbaToCpp()

InputPort * RuntimeSALOME::adaptCorbaToCpp ( InputCorbaPort *  inport, TypeCode *  type  )

virtual

Adapt a CORBA input port to a C++ output port.

Parameters

inport	: input port to adapt to C++ type type
type	: outport data type

Returns

an adaptator port of type InputCPPPort

Definition at line 1352 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptCorbaToCpp(InputCorbaPort* inport" );
  if(isAdaptableCorbaCpp(type,inport->edGetType()))
    {
      //output type is convertible to input type
      return new CppCorba(inport);
    }
  //output type is not convertible
  stringstream msg;
  msg << "Cannot connect Cpp output port with type: " << type->id() ;
  msg << " to Corba input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptableCorbaCpp().

adaptCorbaToNeutral()

InputPort * RuntimeSALOME::adaptCorbaToNeutral ( InputCorbaPort *  inport, TypeCode *  type  )

virtual

Adapt a CORBA input port to a neutral data.

Parameters

inport	: InputPort to adapt to Neutral type type
type	: outport data type

Returns

an adaptator port of type Neutralxxxx

Definition at line 1378 of file RuntimeSALOME.cxx.

{
  if(inport->edGetType()->kind() == Double)
    {
      if(isAdaptableCorbaNeutral(type,inport->edGetType()))return new NeutralCorbaDouble(inport);
    }
  else if(inport->edGetType()->kind() == Int)
    {
      if(isAdaptableCorbaNeutral(type,inport->edGetType()))return new NeutralCorbaInt(inport);
    }
  else if(inport->edGetType()->kind() == String)
    {
      if(isAdaptableCorbaNeutral(type,inport->edGetType())) return new NeutralCorbaString(inport);
    }
  else if(inport->edGetType()->kind() == Bool)
    {
      if(isAdaptableCorbaNeutral(type,inport->edGetType()))return new NeutralCorbaBool(inport);
    }
  else if(inport->edGetType()->kind() == Objref)
    {
      if(isAdaptableCorbaNeutral(type,inport->edGetType())) return new NeutralCorbaObjref(inport);
    }
  else if(inport->edGetType()->kind() == Sequence)
    {
      if(isAdaptableCorbaNeutral(type,inport->edGetType()))
        return new NeutralCorbaSequence(inport);
      else
        {
          stringstream msg;
          msg << "Cannot convert this sequence type " ;
          msg << __FILE__ << ":" <<__LINE__;
          throw ConversionException(msg.str());
        }
    }
  else if(inport->edGetType()->kind() == Struct)
    {
      if(isAdaptableCorbaNeutral(type,inport->edGetType())) return new NeutralCorbaStruct(inport);
    }
 
  // Adaptation not possible
  stringstream msg;
  msg << "Cannot connect Neutral output port with type: " << type->id() ;
  msg << " to Corba input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::Bool, YACS::ENGINE::Double, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::Int, YACS::ENGINE::isAdaptableCorbaNeutral(), YACS::ENGINE::TypeCode::kind(), YACS::ENGINE::Objref, YACS::ENGINE::Sequence, YACS::ENGINE::String, and YACS::ENGINE::Struct.

adaptCorbaToPython()

InputPort * RuntimeSALOME::adaptCorbaToPython ( InputCorbaPort *  inport, TypeCode *  type  )

virtual

Adapt a CORBA input port to a Python output port.

Parameters

inport	: input port to adapt to Python type type
type	: outport data type

Returns

an adaptator port of type InputPyPort

Definition at line 1247 of file RuntimeSALOME.cxx.

{
  if(inport->edGetType()->kind() == Double)
    {
      if(isAdaptableCorbaPyObject(type,inport->edGetType()))return new PyCorbaDouble(inport);
    }
  else if(inport->edGetType()->kind() == Int)
    {
      if(isAdaptableCorbaPyObject(type,inport->edGetType()))return new PyCorbaInt(inport);
    }
  else if(inport->edGetType()->kind() == String)
    {
      if(isAdaptableCorbaPyObject(type,inport->edGetType()))return new PyCorbaString(inport);
    }
  else if(inport->edGetType()->kind() == Bool)
    {
      if(isAdaptableCorbaPyObject(type,inport->edGetType()))return new PyCorbaBool(inport);
    }
  else if(inport->edGetType()->kind() == Objref )
    {
      if(isAdaptableCorbaPyObject(type,inport->edGetType()))
        {
          return new PyCorbaObjref(inport);
        }
      else
        {
          stringstream msg;
          msg << "Cannot connect Python output port with type: " << type->id() ;
          msg << " to CORBA input port " << inport->getName() << " with incompatible objref type: " << inport->edGetType()->id();
          msg << " (" << __FILE__ << ":" <<__LINE__ << ")";
          throw ConversionException(msg.str());
        }
    }
  else if(inport->edGetType()->kind() == Sequence)
    {
      if(isAdaptableCorbaPyObject(type,inport->edGetType()))
        {
          return new PyCorbaSequence(inport);
        }
      else
        {
          stringstream msg;
          msg << "Cannot convert this sequence type " ;
          msg << __FILE__ << ":" <<__LINE__;
          throw ConversionException(msg.str());
        }
    }
  else if(inport->edGetType()->kind() == YACS::ENGINE::Struct)
    {
      if(isAdaptableCorbaPyObject(type,inport->edGetType()))
        {
          return new PyCorbaStruct(inport);
        }
      else
        {
          stringstream msg;
          msg << "Cannot convert this struct type " << type->id() << " to " << inport->edGetType()->id();
          msg << __FILE__ << ":" <<__LINE__;
          throw ConversionException(msg.str());
        }
    }
  // Adaptation not possible
  stringstream msg;
  msg << "Cannot connect Python output port with type: " << type->id() ;
  msg << " to CORBA input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::Bool, YACS::ENGINE::Double, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::Int, YACS::ENGINE::isAdaptableCorbaPyObject(), YACS::ENGINE::TypeCode::kind(), YACS::ENGINE::Objref, YACS::ENGINE::Sequence, YACS::ENGINE::String, and YACS::ENGINE::Struct.

adaptCorbaToXml()

InputPort * RuntimeSALOME::adaptCorbaToXml ( InputCorbaPort *  inport, TypeCode *  type  )

virtual

Adapt a CORBA input port to connect it to a XML output port.

Parameters

inport	: input port to adapt to Xml type type
type	: type supported by output port

Returns

an adaptator port of type InputXmlPort

Definition at line 1326 of file RuntimeSALOME.cxx.

{
  // BEWARE : using the generic check
  if(inport->edGetType()->isAdaptable(type))
    {
      //output type is convertible to input type
      return new XmlCorba(inport);
    }
  //output type is not convertible
  stringstream msg;
  msg << "Cannot connect Xml output port with type: " << type->id() ;
  msg << " to Corba input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::TypeCode::isAdaptable().

adaptCppToCorba()

InputPort * RuntimeSALOME::adaptCppToCorba ( InputCppPort *  inport, TypeCode *  type  )

virtual

Adapt a C++ input port to connect it to a CORBA output port.

Parameters

inport	: input port to adapt to CORBA type type
type	: type supported by output port

Returns

an adaptator port of type InputCorbaPort

Definition at line 1744 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptCppToCorba(InputCppPort* inport)");
  if(isAdaptableCppCorba(type,inport->edGetType()))
    {
      //output type is convertible to input type
      return new CorbaCpp(inport);
    }
  //output type is not convertible
  stringstream msg;
  msg << "Cannot connect Corba output port with type: " << type->id() ;
  msg << " to Cpp input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptableCppCorba().

adaptCppToCpp()

InputPort * RuntimeSALOME::adaptCppToCpp ( InputCppPort *  inport, TypeCode *  type  )

virtual

Adapt a C++ input port to a C++ output port.

Parameters

inport	: input port to adapt to C++ type type
type	: output port type

Returns

an adaptated input port of type InputPyPort

Definition at line 1794 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptCppToCpp(InputPort* inport" );
  DEBTRACE(type->kind() << "   " << inport->edGetType()->kind() );
  if(type->isAdaptable(inport->edGetType()))
    {
      //the output data is convertible to inport type
      return new CppCpp(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Cpp output port with type: " << type->id() ;
  msg << " to Cpp input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::TypeCode::isAdaptable(), and YACS::ENGINE::TypeCode::kind().

adaptCppToNeutral()

InputPort * RuntimeSALOME::adaptCppToNeutral ( InputCppPort *  inport, TypeCode *  type  )

virtual

Adapt a C++ input port to a Neutral output port.

Parameters

inport	: input port to adapt to C++ type type
type	: output port type

Returns

an adaptated input port of type InputPyPort

Definition at line 1820 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptCppToNeutral(InputPort* inport" );
  DEBTRACE(type->kind() << "   " << inport->edGetType()->kind() );
  if(type->isAdaptable(inport->edGetType()))
    {
      //the output data is convertible to inport type
      return new NeutralCpp(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Neutral output port with type: " << type->id() ;
  msg << " to Cpp input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::TypeCode::isAdaptable(), and YACS::ENGINE::TypeCode::kind().

adaptCppToPython()

InputPort * RuntimeSALOME::adaptCppToPython ( InputCppPort *  inport, TypeCode *  type  )

virtual

Adapt a C++ input port to a Python output port.

Parameters

inport	: input port to adapt to Python type type
type	: output port type

Returns

an adaptated input port of type InputPyPort

Definition at line 1769 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptCppToPython(InputCppPort* inport)");
  if(isAdaptableCppPyObject(type,inport->edGetType()))
    {
      //output type is convertible to input type
      return new PyCpp(inport);
    }
  //output type is not convertible
  stringstream msg;
  msg << "Cannot connect Python output port with type: " << type->id() ;
  msg << " to Cpp input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptableCppPyObject().

adaptCppToXml()

InputPort * RuntimeSALOME::adaptCppToXml ( InputCppPort *  source, TypeCode *  type  )

virtual

Definition at line 1840 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptCppToXml(InputCppPort* inport" );
  if(isAdaptableCppXml(type,inport->edGetType()))
    {
      //convertible type
      return new XmlCpp(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Xml output port with type: " << type->id() ;
  msg << " to Cpp input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
   throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptableCppXml().

adaptNeutral()

InputPort * RuntimeSALOME::adaptNeutral ( InputPort *  source, const std::string &  impl, TypeCode *  type, bool  init  )

virtual

Adapt a Neutral input port to connect it to an output port with a given implementation.

Parameters

source	: Neutral input port to adapt to implementation impl and type type
impl	: output port implementation (C++, Python, Corba, Xml or Neutral)
type	: output port supported type
init	: if init is true the proxy port will be used in initialization of input port (needs value check)

Returns

the adaptated port

Definition at line 1012 of file RuntimeSALOME.cxx.

{
  if(impl == CppNode::IMPL_NAME)
    {
      return adaptNeutralToCpp(source,type);
    }
  else if(impl == PythonNode::IMPL_NAME)
    {
      return adaptNeutralToPython(source,type);
    }
  else if(impl == CORBANode::IMPL_NAME)
    {
      return adaptNeutralToCorba(source,type);
    }
  else if(impl == XmlNode::IMPL_NAME )
    {
      return adaptNeutralToXml(source,type);
    }
  else if(impl == Runtime::RUNTIME_ENGINE_INTERACTION_IMPL_NAME)
    {
      if(init)
        return new NeutralInit(source);
      else
        return new ProxyPort(source);
    }
  stringstream msg;
  msg << "Cannot connect InputPort : unknown implementation " << impl;
  msg << " (" <<__FILE__ << ":" <<__LINE__ << ")";
  throw ConversionException(msg.str());
}

adaptNeutralToCorba()

InputPort * RuntimeSALOME::adaptNeutralToCorba ( InputPort *  inport, TypeCode *  type  )

virtual

Adapt a Neutral input port to a Corba output port.

Parameters

inport	: Neutral input port to adapt to Corba type type
type	: output port type

Returns

an adaptated input port of type InputCorbaPort

Definition at line 905 of file RuntimeSALOME.cxx.

{
  // BEWARE : using the generic check
  if(inport->edGetType()->isAdaptable(type))
    {
      //the output data is convertible to inport type
      return new CorbaNeutral(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Corba output port with type: " << type->id() ;
  msg << " to Neutral input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::TypeCode::isAdaptable().

adaptNeutralToCpp()

InputPort * RuntimeSALOME::adaptNeutralToCpp ( InputPort *  inport, TypeCode *  type  )

virtual

Adapt a Neutral input port to a C++ output port.

Parameters

inport	: input port to adapt to C++ type type
type	: output port type

Returns

an input port of type InputCppPort

Definition at line 985 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptNeutralToCpp(InputPort* inport" );
  if(isAdaptableNeutralCpp(type,inport->edGetType()))
    {
      //convertible type
      return new CppNeutral(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Cpp output port with type: " << type->id() ;
  msg << " to Neutral input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptableNeutralCpp().

adaptNeutralToPython()

InputPort * RuntimeSALOME::adaptNeutralToPython ( InputPort *  inport, TypeCode *  type  )

virtual

Adapt a Neutral input port to a Python output port.

Parameters

inport	: input port to adapt to Python type type
type	: output port type

Returns

an adaptated input port of type InputPyPort

Definition at line 930 of file RuntimeSALOME.cxx.

{
  // BEWARE : using the generic check
  if(inport->edGetType()->isAdaptable(type))
    {
      //convertible type
      return new PyNeutral(inport);
    }
  //last chance : an py output that is seq[objref] can be connected to a neutral input objref (P13268)
  else if(type->kind()==Sequence && type->contentType()->kind()==Objref && inport->edGetType()->kind()==Objref)
    {
      return new PyNeutral(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Python output port with type: " << type->id() ;
  msg << " to Neutral input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::TypeCode::contentType(), YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::TypeCode::isAdaptable(), YACS::ENGINE::TypeCode::kind(), YACS::ENGINE::Objref, and YACS::ENGINE::Sequence.

adaptNeutralToXml()

InputPort * RuntimeSALOME::adaptNeutralToXml ( InputPort *  inport, TypeCode *  type  )

virtual

Adapt a Neutral input port to a Xml output port.

Parameters

inport	: input port to adapt to Xml type type
type	: output port type

Returns

an input port of type InputXmlPort

Definition at line 960 of file RuntimeSALOME.cxx.

{
  // BEWARE : using the generic check
  if(inport->edGetType()->isAdaptable(type))
    {
      //convertible type
      return new XmlNeutral(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Xml output port with type: " << type->id() ;
  msg << " to Neutral input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::TypeCode::isAdaptable().

adaptPythonToCorba()

InputPort * RuntimeSALOME::adaptPythonToCorba ( InputPyPort *  inport, TypeCode *  type  )

virtual

Adapt a Python input port to a Corba output port.

Always convert the data

Parameters

inport	: InputPort to adapt to Corba type type
type	: outport data type

Returns

an adaptator port of Corba type (InputCorbaPort)

Definition at line 1597 of file RuntimeSALOME.cxx.

{
  if(inport->edGetType()->kind() == Double)
    {
      if(isAdaptablePyObjectCorba(type,inport->edGetType()))return new CorbaPyDouble(inport);
    }
  else if(inport->edGetType()->kind() == Int)
    {
      if(isAdaptablePyObjectCorba(type,inport->edGetType()))return new CorbaPyInt(inport);
    }
  else if(inport->edGetType()->kind() == String)
    {
      if(isAdaptablePyObjectCorba(type,inport->edGetType()))return new CorbaPyString(inport);
    }
  else if(inport->edGetType()->kind() == Bool)
    {
      if(isAdaptablePyObjectCorba(type,inport->edGetType()))return new CorbaPyBool(inport);
    }
  else if(inport->edGetType()->kind() == Objref)
    {
      if(isAdaptablePyObjectCorba(type,inport->edGetType()))
        {
          return new CorbaPyObjref(inport);
        }
      else
        {
          stringstream msg;
          msg << "Cannot connect InputCorbaPort : incompatible objref types " << type->id() << " " << inport->edGetType()->id();
          msg << " " << __FILE__ << ":" <<__LINE__;
          throw ConversionException(msg.str());
        }
    }
  else if(inport->edGetType()->kind() == Sequence)
    {
      if(isAdaptablePyObjectCorba(type,inport->edGetType()))
        {
          return new CorbaPySequence(inport);
        }
      else
        {
          stringstream msg;
          msg << "Cannot convert this sequence type " ;
          msg << __FILE__ << ":" <<__LINE__;
          throw ConversionException(msg.str());
        }
    }
  else if(inport->edGetType()->kind() == YACS::ENGINE::Struct)
    {
      if(isAdaptablePyObjectCorba(type,inport->edGetType()))
        {
          return new CorbaPyStruct(inport);
        }
      else
        {
          stringstream msg;
          msg << "Cannot convert this struct type " << type->id() << " to " << inport->edGetType()->id();
          msg << " " << __FILE__ << ":" <<__LINE__;
          throw ConversionException(msg.str());
        }
    }
  // Adaptation not possible
  stringstream msg;
  msg << "Cannot connect Corba output port with type: " << type->id() ;
  msg << " to Python input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg << " ("__FILE__ << ":" << __LINE__ << ")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::Bool, YACS::ENGINE::Double, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::Int, YACS::ENGINE::isAdaptablePyObjectCorba(), YACS::ENGINE::TypeCode::kind(), YACS::ENGINE::Objref, YACS::ENGINE::Sequence, YACS::ENGINE::String, and YACS::ENGINE::Struct.

adaptPythonToCpp()

InputPort * RuntimeSALOME::adaptPythonToCpp ( InputPyPort *  inport, TypeCode *  type  )

virtual

Adapt a Python input port to a C++ output port.

Parameters

inport	: InputPort to adapt to C++ type type
type	: outport data type

Returns

an adaptator port of C++ type (InputCppPort)

Definition at line 1513 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptPythonToCpp(InputPyPort* inport" );
  if(isAdaptablePyObjectCpp(type,inport->edGetType()))
    {
      //output type is convertible to input type
      return new CppPy(inport);
    }
  //output type is not convertible
  stringstream msg;
  msg << "Cannot connect Cpp output port with type: " << type->id() ;
  msg << " to Python input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptablePyObjectCpp().

adaptPythonToNeutral()

InputPort * RuntimeSALOME::adaptPythonToNeutral ( InputPyPort *  inport, TypeCode *  type  )

virtual

Adapt a Python input port to a Neutral data port.

Parameters

inport	: InputPort to adapt to Neutral type type
type	: outport data type

Returns

an adaptator port of Neutral type (Neutralxxxx)

Definition at line 1539 of file RuntimeSALOME.cxx.

{
  if(inport->edGetType()->kind() == Double)
    {
      if(isAdaptablePyObjectNeutral(type,inport->edGetType()))return new NeutralPyDouble(inport);
    }
  else if(inport->edGetType()->kind() == Int)
    {
      if(isAdaptablePyObjectNeutral(type,inport->edGetType()))return new NeutralPyInt(inport);
    }
  else if(inport->edGetType()->kind() == String)
    {
      if(isAdaptablePyObjectNeutral(type,inport->edGetType()))return new NeutralPyString(inport);
    }
  else if(inport->edGetType()->kind() == Bool)
    {
      if(isAdaptablePyObjectNeutral(type,inport->edGetType()))return new NeutralPyBool(inport);
    }
  else if(inport->edGetType()->kind() == Objref)
    {
      if(isAdaptablePyObjectNeutral(type,inport->edGetType()))return new NeutralPyObjref(inport);
    }
  else if(inport->edGetType()->kind() == Sequence)
    {
      if(isAdaptablePyObjectNeutral(type,inport->edGetType()))
        return new NeutralPySequence(inport);
      else
        {
          stringstream msg;
          msg << "Cannot convert this sequence type " ;
          msg << __FILE__ << ":" <<__LINE__;
          throw ConversionException(msg.str());
        }
    }
  else if(inport->edGetType()->kind() == Struct)
    {
      if(isAdaptablePyObjectNeutral(type,inport->edGetType())) return new NeutralPyStruct(inport);
    }
 
  // Adaptation not possible
  stringstream msg;
  msg << "Cannot connect Neutral output port with type: " << type->id() ;
  msg << " to Python input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::Bool, YACS::ENGINE::Double, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::Int, YACS::ENGINE::isAdaptablePyObjectNeutral(), YACS::ENGINE::TypeCode::kind(), YACS::ENGINE::Objref, YACS::ENGINE::Sequence, YACS::ENGINE::String, and YACS::ENGINE::Struct.

adaptPythonToPython()

InputPort * RuntimeSALOME::adaptPythonToPython ( InputPyPort *  inport, TypeCode *  type, bool  init  )

virtual

Adapt a Python input port to a Python output port.

No need to make conversion or cast. Only check, it's possible.

Parameters

inport	: InputPort to adapt to Python type type
type	: outport data type
init	: if init is true the proxy port will be used in initialization of input port (needs value check)

Returns

an adaptator port of type InputPyPort

Definition at line 1483 of file RuntimeSALOME.cxx.

{
  if(init)
    return new PyInit(inport);
 
  if(isAdaptablePyObjectPyObject(type,inport->edGetType()))
    {
      //output data is convertible to input type
      //With python, no need to convert. Conversion will be done automatically
      //by the interpreter
      return new ProxyPort(inport);
    }
  //output data is not convertible to input type
  stringstream msg;
  msg << "Cannot connect Python output port with type: " << type->id() ;
  msg << " to Python input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptablePyObjectPyObject().

adaptPythonToXml()

InputPort * RuntimeSALOME::adaptPythonToXml ( InputPyPort *  inport, TypeCode *  type  )

virtual

Adapt a Python input port to a Xml output port.

Parameters

inport	: input port to adapt to Xml type type
type	: output port type

Returns

an input port of type InputXmlPort

Definition at line 1675 of file RuntimeSALOME.cxx.

{
  // BEWARE : using the generic check
  if(inport->edGetType()->isAdaptable(type))
    {
      //convertible type
      return new XmlPython(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Xml output port with type: " << type->id() ;
  msg << " to Python input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::TypeCode::isAdaptable().

adaptXmlToCorba()

InputPort * RuntimeSALOME::adaptXmlToCorba ( InputXmlPort *  inport, TypeCode *  type  )

virtual

Adapt a XML input port to connect it to a CORBA output port.

Parameters

inport	: input port to adapt to CORBA type type
type	: type supported by output port

Returns

an adaptator port of type InputCorbaPort

Definition at line 1052 of file RuntimeSALOME.cxx.

{
  if(isAdaptableXmlCorba(type,inport->edGetType()))
    {
      //output type is convertible to input type
      return new CorbaXml(inport);
    }
  //output type is not convertible
  stringstream msg;
  msg << "Cannot connect Corba output port with type: " << type->id() ;
  msg << " to Xml input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::isAdaptableXmlCorba().

adaptXmlToCpp()

InputPort * RuntimeSALOME::adaptXmlToCpp ( InputXmlPort *  inport, TypeCode *  type  )

virtual

Adapt a XML input port to a C++ output port.

Parameters

inport	: input port to adapt to C++ type type
type	: output port type

Returns

an adaptated input port of type InputPyPort

Definition at line 1100 of file RuntimeSALOME.cxx.

{
  DEBTRACE("RuntimeSALOME::adaptXmlToCpp(InputPort* inport" );
  DEBTRACE(type->kind() << "   " << inport->edGetType()->kind() );
  if(type->isAdaptable(inport->edGetType()))
    {
      //the output data is convertible to inport type
      return new CppXml(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Cpp output port with type: " << type->id() ;
  msg << " to Xml input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References DEBTRACE, YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), YACS::ENGINE::TypeCode::isAdaptable(), and YACS::ENGINE::TypeCode::kind().

adaptXmlToNeutral()

InputPort * RuntimeSALOME::adaptXmlToNeutral ( InputXmlPort *  inport, TypeCode *  type  )

virtual

Adapt a XML input port to a Neutral output port.

Parameters

inport	: input port to adapt to Neutral type type
type	: output port type

Returns

an adaptated input port of type Neutralxxxx

Definition at line 1126 of file RuntimeSALOME.cxx.

{
  if(inport->edGetType()->isAdaptable(type))
    {
      //the output data is convertible to inport type
      return new NeutralXml(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Xml InputPort to OutputNeutralPort : " ;
  msg << "(" <<__FILE__ << ":" <<__LINE__<< ")";
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), and YACS::ENGINE::TypeCode::isAdaptable().

adaptXmlToPython()

InputPort * RuntimeSALOME::adaptXmlToPython ( InputXmlPort *  inport, TypeCode *  type  )

virtual

Adapt a XML input port to a Python output port.

Parameters

inport	: input port to adapt to Python type type
type	: output port type

Returns

an adaptated input port of type InputPyPort

Definition at line 1076 of file RuntimeSALOME.cxx.

{
  if(inport->edGetType()->isAdaptable(type))
    {
      //the output data is convertible to inport type
      return new PyXml(inport);
    }
  //non convertible type
  stringstream msg;
  msg << "Cannot connect Python output port with type: " << type->id() ;
  msg << " to Xml input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::TypeCode::isAdaptable().

adaptXmlToXml()

InputPort * RuntimeSALOME::adaptXmlToXml ( InputXmlPort *  inport, TypeCode *  type, bool  init  )

virtual

Adapt a XML input port to a Xml output port.

Parameters

inport	: input port to adapt to Xml type type
type	: output port type
init	: if init is true the proxy port will be used in initialization of input port (needs value check)

Returns

an adaptated input port of type Xmlxxxx

Definition at line 1148 of file RuntimeSALOME.cxx.

{
  if(init)
    return new ProxyPort(inport);
 
  if(inport->edGetType()->isAdaptable(type))
    return new ProxyPort(inport);
 
  stringstream msg;
  msg << "Cannot connect Xml output port with type: " << type->id() ;
  msg << " to Xml input port " << inport->getName() << " with type: " << inport->edGetType()->id();
#ifdef _DEVDEBUG_
  msg <<  " ("<<__FILE__ << ":" << __LINE__<<")";
#endif
  throw ConversionException(msg.str());
}

References YACS::ENGINE::DataPort::edGetType(), YACS::ENGINE::DataPort::getName(), YACS::ENGINE::TypeCode::id(), and YACS::ENGINE::TypeCode::isAdaptable().

convertNeutral()

void * RuntimeSALOME::convertNeutral ( TypeCode *  type, Any *  data  )

virtual

Convert a YACS::ENGINE::Any object to an external object with type type.

This method is used to convert Neutral objects to script languages. For example Python language. The runtime has one external script language. The object is returned as a void * because engine knows nothing about external script language.

Parameters

type	the type of the converted object if the conversion is possible
data	the object to convert

Returns

the converted object

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 1969 of file RuntimeSALOME.cxx.

{
  if(data)
    return (void *)convertNeutralPyObject(type,data);
  else
    {
      Py_INCREF(Py_None);
      return (void *)Py_None;
    }
}

References YACS::ENGINE::convertNeutralPyObject().

convertNeutralAsString()

std::string RuntimeSALOME::convertNeutralAsString ( TypeCode *  type, Any *  data  )

virtual

Convert a YACS::ENGINE::Any object to a string to be used in GUI for example.

engine package does not provide a conversion to string. It has to be implemented in the runtime package.

Parameters

type	the type of the object to convert
data	the object to convert

Returns

the string representation of the object

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 1980 of file RuntimeSALOME.cxx.

{
  PyObject* ob;
  if(data)
    {
      // The call to PyGILState_Ensure was moved here because there was also
      // a crash when calling convertNeutralPyObject with a sequence of pyobj.
      // see also the comment below.
      PyGILState_STATE gstate = PyGILState_Ensure();
      ob=convertNeutralPyObject(type,data);
      std::string s=convertPyObjectToString(ob);
 
      // Note (Renaud Barate, 8 jan 2013): With Python 2.7, this call to Py_DECREF causes a crash
      // (SIGSEGV) when ob is a sequence and the call is not protected with the global interpreter
      // lock. I thus added the call to PyGILState_Ensure / PyGILState_Release. It worked fine in
      // Python 2.6 without this call. If anyone finds the real reason of this bug and another fix,
      // feel free to change this code.
      //PyGILState_STATE gstate = PyGILState_Ensure();
      Py_DECREF(ob);
      PyGILState_Release(gstate);
      return s;
    }
  else
    {
      return "None";
    }
}

References YACS::ENGINE::convertNeutralPyObject(), and YACS::ENGINE::convertPyObjectToString().

convertPyObjectToString()

std::string RuntimeSALOME::convertPyObjectToString ( PyObject *  ob )

virtual

Definition at line 2008 of file RuntimeSALOME.cxx.

{
  return YACS::ENGINE::convertPyObjectToString(ob);
}

References YACS::ENGINE::convertPyObjectToString().

convertStringToPyObject()

PyObject * RuntimeSALOME::convertStringToPyObject ( const std::string &  s )

virtual

Definition at line 2013 of file RuntimeSALOME.cxx.

{
  PyObject *mainmod;
  PyObject *globals;
  PyObject* ob;
  PyGILState_STATE gstate = PyGILState_Ensure();
  mainmod = PyImport_AddModule("__main__");
  globals = PyModule_GetDict(mainmod);
  PyObject* d = PyDict_New();
  //PyDict_SetItemString(d, "__builtins__", PyEval_GetBuiltins());
  ob= PyRun_String( s.c_str(), Py_eval_input, globals, d);
  Py_DECREF(d);
  if(ob==NULL)
    {
      //exception
      std::string error;
      PyObject* new_stderr = newPyStdOut(error);
      PySys_SetObject((char *)"stderr", new_stderr);
      PyErr_Print();
      PySys_SetObject((char *)"stderr", PySys_GetObject((char *)"__stderr__"));
      Py_DECREF(new_stderr);
      PyGILState_Release(gstate);
      throw Exception(error);
    }
  PyGILState_Release(gstate);
  return ob;
}

References YACS::ENGINE::newPyStdOut().

Referenced by YACS::HMI::CommandSetInPortValue::localExecute(), YACS::HMI::CommandSetOutPortValue::localExecute(), YACS::HMI::CommandSetInPortValue::localReverse(), and YACS::HMI::CommandSetOutPortValue::localReverse().

createBloc()

Bloc * RuntimeSALOME::createBloc ( const std::string &  name )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 599 of file RuntimeSALOME.cxx.

{
  return new Bloc(name);
}

createComponentInstance()

ComponentInstance * RuntimeSALOME::createComponentInstance ( const std::string &  name, const std::string &  kind = ""  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 722 of file RuntimeSALOME.cxx.

{
  ComponentInstance* compo;
  if(kind == "" || kind == SalomeComponent::KIND) 
    return new SalomeComponent(name);
  else if(kind == CORBAComponent::KIND)
    return new CORBAComponent(name);
  else if(kind == SalomePythonComponent::KIND)
    return new SalomePythonComponent(name);
  else if (kind == CppComponent::KIND)
    return new CppComponent(name);
  else if (kind == SalomeHPComponent::KIND)
    return new SalomeHPComponent(name);
  std::string msg="Component Instance kind ("+kind+") unknown";
  throw Exception(msg);
}

createCompoNode()

ServiceNode * RuntimeSALOME::createCompoNode ( const std::string &  kind, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 697 of file RuntimeSALOME.cxx.

{
  ServiceNode* node;
  if(kind == "" || kind == SalomeNode::KIND )
    {
      node=new SalomeNode(name);
      return node;
    }
  else if (kind == CppNode::KIND) 
    {
      node = new CppNode(name);
      return node;
    }
  std::string msg="CompoNode kind ("+kind+") unknown";
  throw Exception(msg);
}

createContainer()

Container * RuntimeSALOME::createContainer ( const std::string &  kind = "" )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 740 of file RuntimeSALOME.cxx.

{
  if(kind == "" || kind == SalomeContainer::KIND)
    return new SalomeContainer;
  if(kind==SalomeHPContainer::KIND)
    return new SalomeHPContainer;
  else if (kind == CppContainer::KIND)
    return new CppContainer;
  std::string msg="Container kind ("+kind+") unknown";
  throw Exception(msg);
}

createForLoop()

ForLoop * RuntimeSALOME::createForLoop ( const std::string &  name )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 609 of file RuntimeSALOME.cxx.

{
  return new ForLoop(name);
}

createFuncNode()

InlineFuncNode * RuntimeSALOME::createFuncNode ( const std::string &  kind, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 654 of file RuntimeSALOME.cxx.

{
  InlineFuncNode* node;
  if(kind == "" || kind == SalomeNode::KIND || kind == PythonNode::KIND)
    {
      node = new PyFuncNode(name);
      return node;
    }
  if(kind == DistributedPythonNode::KIND)
    return new DistributedPythonNode(name);
  std::string msg="FuncNode kind ("+kind+") unknown";
  throw Exception(msg);
}

createInDataNode()

DataNode * RuntimeSALOME::createInDataNode ( const std::string &  kind, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 623 of file RuntimeSALOME.cxx.

{
  DataNode* node;
  if(kind == "" )
    {
      node = new PresetNode(name);
      return node;
    }
  else if(kind == "study" )
    {
      return new StudyInNode(name);
    }
  std::string msg="DataNode kind ("+kind+") unknown";
  throw Exception(msg);
}

createInputDataStreamPort()

InputDataStreamPort * RuntimeSALOME::createInputDataStreamPort ( const std::string &  name, Node *  node, TypeCode *  type  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 812 of file RuntimeSALOME.cxx.

{
  DEBTRACE("createInputDataStreamPort: " << name << " " << type->shortName());
  if(type->kind() == Objref && std::string(type->shortName(),7) == "CALCIUM")
    {
      return new InputCalStreamPort(name,node,type);
    }
  else
    {
      return new InputDataStreamPort(name,node,type);
    }
}

References DEBTRACE, YACS::ENGINE::TypeCode::kind(), YACS::ENGINE::Objref, and YACS::ENGINE::TypeCode::shortName().

createInputPort()

InputPort * RuntimeSALOME::createInputPort ( const std::string &  name, const std::string &  impl, Node *  node, TypeCode *  type  )

virtual

Implements YACS::ENGINE::Runtime.

Definition at line 752 of file RuntimeSALOME.cxx.

{
  if(impl == CppNode::IMPL_NAME)
    {
      return new InputCppPort(name, node, type);
    }
  else if(impl == PythonNode::IMPL_NAME)
    {
      return new InputPyPort(name, node, type);
    }
  else if(impl == CORBANode::IMPL_NAME)
    {
      return new InputCorbaPort(name, node, type);
    }
  else if(impl == XmlNode::IMPL_NAME)
    {
      return new InputXmlPort(name, node, type);
    }
  else
    {
      stringstream msg;
      msg << "Cannot create " << impl << " InputPort" ;
      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
      throw Exception(msg.str());
    }
}

createInterfaceTc()

TypeCode * RuntimeSALOME::createInterfaceTc ( const std::string &  id, const std::string &  name, std::list< TypeCodeObjref * >  ltc  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 575 of file RuntimeSALOME.cxx.

{
  std::string myName;
  if(id == "") myName = "IDL:" + name + ":1.0";
  else myName = id;
  return TypeCode::interfaceTc(myName.c_str(),name.c_str(),ltc);
}

createOptimizerLoop()

OptimizerLoop * RuntimeSALOME::createOptimizerLoop ( const std::string &  name, const std::string &  algLib, const std::string &  factoryName, bool  algInitOnFile, const std::string &  kind = "", Proc *  procForTypes = NULL  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 614 of file RuntimeSALOME.cxx.

{
  OptimizerLoop * ol = (kind == "base") ? new OptimizerLoop(name,algLib,factoryName,algInitOnFile, true, procForTypes) :
                                          new SalomeOptimizerLoop(name,algLib,factoryName,algInitOnFile, true, procForTypes);
  ol->edGetNbOfBranchesPort()->edInit(1);
  return ol;
}

References YACS::ENGINE::DynParaLoop::edGetNbOfBranchesPort(), and YACS::ENGINE::InputPort::edInit().

createOutDataNode()

DataNode * RuntimeSALOME::createOutDataNode ( const std::string &  kind, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 639 of file RuntimeSALOME.cxx.

{
  if(kind == "" )
    {
      return new OutNode(name);
    }
  else if(kind == "study" )
    {
      return new StudyOutNode(name);
    }
 
  std::string msg="OutDataNode kind ("+kind+") unknown";
  throw Exception(msg);
}

createOutputDataStreamPort()

OutputDataStreamPort * RuntimeSALOME::createOutputDataStreamPort ( const std::string &  name, Node *  node, TypeCode *  type  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 826 of file RuntimeSALOME.cxx.

{
  DEBTRACE("createOutputDataStreamPort: " << name << " " << type->shortName());
  if(type->kind() == Objref && std::string(type->shortName(),7) == "CALCIUM")
    {
      return new OutputCalStreamPort(name,node,type);
    }
  else
    {
      return new OutputDataStreamPort(name,node,type);
    }
}

References DEBTRACE, YACS::ENGINE::TypeCode::kind(), YACS::ENGINE::Objref, and YACS::ENGINE::TypeCode::shortName().

createOutputPort()

OutputPort * RuntimeSALOME::createOutputPort ( const std::string &  name, const std::string &  impl, Node *  node, TypeCode *  type  )

virtual

Implements YACS::ENGINE::Runtime.

Definition at line 782 of file RuntimeSALOME.cxx.

{
  if(impl == CppNode::IMPL_NAME)
    {
      return new OutputCppPort(name, node, type);
    }
  else if(impl == PythonNode::IMPL_NAME)
    {
      return new OutputPyPort(name, node, type);
    }
  else if(impl == CORBANode::IMPL_NAME)
    {
      return new OutputCorbaPort(name, node, type);
    }
  else if(impl == XmlNode::IMPL_NAME)
    {
      return new OutputXmlPort(name, node, type);
    }
  else
    {
      stringstream msg;
      msg << "Cannot create " << impl << " OutputPort" ;
      msg << " (" << __FILE__ << ":" << __LINE__ << ")";
      throw Exception(msg.str());
    }
}

createProc()

Proc * RuntimeSALOME::createProc ( const std::string &  name )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 570 of file RuntimeSALOME.cxx.

{
  return new SalomeProc(name);
}

Referenced by YACS::HMI::Invocator::Invocator(), and YACS::HMI::GenericGui::onNewSchema().

createRefNode()

ServiceNode * RuntimeSALOME::createRefNode ( const std::string &  kind, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 680 of file RuntimeSALOME.cxx.

{
  ServiceNode* node;
  if(kind == "" || kind == SalomeNode::KIND || kind == CORBANode::KIND)
    {
      node = new CORBANode(name);
      return node;
    }
  else if(kind == XmlNode::KIND)
    {
      node = new XmlNode(name);
      return node;
    }
  std::string msg="RefNode kind ("+kind+") unknown";
  throw Exception(msg);
}

createScriptNode()

InlineNode * RuntimeSALOME::createScriptNode ( const std::string &  kind, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 668 of file RuntimeSALOME.cxx.

{
  InlineNode* node;
  if(kind == "" || kind == SalomeNode::KIND || kind == PythonNode::KIND)
    {
      node = new PythonNode(name);
      return node;
    }
  std::string msg="ScriptNode kind ("+kind+") unknown";
  throw Exception(msg);
}

createSequenceTc()

TypeCode * RuntimeSALOME::createSequenceTc ( const std::string &  id, const std::string &  name, TypeCode *  content  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 584 of file RuntimeSALOME.cxx.

{
  return TypeCode::sequenceTc(id.c_str(),name.c_str(),content);
};

createSInlineNode()

ServiceInlineNode * RuntimeSALOME::createSInlineNode ( const std::string &  kind, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 714 of file RuntimeSALOME.cxx.

{
  if(kind == "" || kind == SalomeNode::KIND )
    return new SalomePythonNode(name);
  std::string msg="CompoNode kind ("+kind+") unknown";
  throw Exception(msg);
}

createStructTc()

TypeCodeStruct * RuntimeSALOME::createStructTc ( const std::string &  id, const std::string &  name  )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 591 of file RuntimeSALOME.cxx.

{
  std::string myName;
  if(id == "") myName = "IDL:" + name + ":1.0";
  else myName = id;
  return (TypeCodeStruct *)TypeCode::structTc(myName.c_str(),name.c_str());
}

createWhileLoop()

WhileLoop * RuntimeSALOME::createWhileLoop ( const std::string &  name )

virtual

Reimplemented from YACS::ENGINE::Runtime.

Definition at line 604 of file RuntimeSALOME.cxx.

{
  return new WhileLoop(name);
}

fini()

void RuntimeSALOME::fini ( bool  isFinalizingPython = true )

virtual

Definition at line 423 of file RuntimeSALOME.cxx.

{
  if (_usePython)
    {
      PyGILState_STATE gstate = PyGILState_Ensure();
#ifdef REFCNT
      DEBTRACE("_orb refCount: " << ((omniOrbORB*)_orb.in())->pd_refCount);
#endif
      PyObject *mainmod, *globals;
      mainmod = PyImport_AddModule("__main__");
      globals = PyModule_GetDict(mainmod);
      if (_useCorba)
        {
          PyObject* res;
          res=PyRun_String("orb.destroy()\n"
                           "\n",
                           Py_file_input,globals,globals );
          if(res == NULL)
            PyErr_Print();
          else
            Py_DECREF(res);
        }
      std::map<std::string,Node*>& nodeMap=_builtinCatalog->_nodeMap;
      delete nodeMap["PyFunction"];
      delete nodeMap["PyScript"];
      delete nodeMap["SalomePythonNode"];
      nodeMap.erase("PyFunction");
      nodeMap.erase("PyScript");
      nodeMap.erase("SalomePythonNode");
      
      if( isFinalizingPython )
        Py_Finalize();
#ifdef REFCNT
      DEBTRACE("_orb refCount: " << ((omniOrbORB*)_orb.in())->pd_refCount);
#endif
    }
  else
    {
      if (_useCorba)
        {
#ifdef REFCNT
          DEBTRACE("_orb refCount: " << ((omniOrbORB*)_orb.in())->pd_refCount);
#endif
          _orb->destroy();
        }
    }
}

References DEBTRACE.

get_omnipy()

PyObject * RuntimeSALOME::get_omnipy

(

)

Definition at line 1959 of file RuntimeSALOME.cxx.

{
  return _omnipy;
}

getApi()

omniORBpyAPI * RuntimeSALOME::getApi

(

)

Definition at line 1964 of file RuntimeSALOME.cxx.

{
  return _api;
}

Referenced by YACS::ENGINE::convertFromYacsObjref< PYTHONImpl, PyObject * >::convert().

getBuiltins()

PyObject * RuntimeSALOME::getBuiltins

(

)

const

Definition at line 1949 of file RuntimeSALOME.cxx.

{
  return _bltins;
}

getCatalogOfComputeNodes()

std::vector< std::pair< std::string, int > > RuntimeSALOME::getCatalogOfComputeNodes ( ) const

virtual

Implements YACS::ENGINE::Runtime.

Definition at line 503 of file RuntimeSALOME.cxx.

{
  CORBA::ORB_ptr orb(getOrb());
  SALOME_NamingService_Wrapper namingService;
  try
  {
    namingService.init_orb(orb);
  }
  catch(SALOME_Exception& e)
  {
    throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Unable to contact the SALOME Naming Service");
  }
  CORBA::Object_var obj(namingService.Resolve(SALOME_ResourcesManager::_ResourcesManagerNameInNS));
  if(CORBA::is_nil(obj))
    throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Unable to access to the resource manager !");
  Engines::ResourcesManager_var resManager(Engines::ResourcesManager::_narrow(obj));
  if(CORBA::is_nil(resManager))
    throw Exception("RuntimeSALOME::getCatalogOfComputeNodes : Internal error ! The entry attached to the res manager in NS does not have right type !");
  std::vector< std::pair<std::string,int> > ret;
  Engines::ResourceParameters params;
  params.name = "";
  params.hostname = "";
  params.OS = "";
  params.nb_proc = 0;
  params.mem_mb = 0;
  params.cpu_clock = 0;
  params.nb_node = 0;
  params.nb_proc_per_node = 0;
  params.policy = "";
  params.can_launch_batch_jobs = false;
  params.can_run_containers = true;
  params.componentList.length(0);
  try
  {
    Engines::ResourceList_var resourceList;
    resourceList = resManager->GetFittingResources(params);
    ret.reserve(resourceList->length());
    for(int i = 0; i<resourceList->length(); i++)
    {
      const char* resource_name = resourceList[i];
      std::string std_resource_name = resource_name;
      Engines::ResourceDefinition_var resource_definition
                              = resManager->GetResourceDefinition(resource_name);
      int nb_cores = resource_definition->nb_node *
                     resource_definition->nb_proc_per_node;
      ret.push_back(std::pair<std::string,int>(resource_name, nb_cores));
    }
  }
  catch(SALOME::SALOME_Exception& e)
  {
    std::string message;
    message=e.details.text.in();
    throw Exception(message);
  }
 
  return ret;
}

References yacsorb.CORBAEngineTest::i, SALOME_NamingService_Wrapper::init_orb(), orb, and SALOME_NamingService_Wrapper::Resolve().

getConnectionManager()

ConnectionManager& YACS::ENGINE::RuntimeSALOME::getConnectionManager ( )

inline

Definition at line 246 of file RuntimeSALOME.hxx.

{return _connectionManager;}

getDynFactory()

DynamicAny::DynAnyFactory_ptr RuntimeSALOME::getDynFactory

(

)

const

Definition at line 1954 of file RuntimeSALOME.cxx.

{
  return _dynFactory;
}

Referenced by YACS::ENGINE::convertToYacsStruct< CORBAImpl, CORBA::Any *, void *, IMPLOUT, TOUT >::convert(), YACS::ENGINE::convertToYacsSequence< CORBAImpl, CORBA::Any *, void *, IMPLOUT, TOUT >::convert(), YACS::ENGINE::convertFromYacsStruct< CORBAImpl, CORBA::Any * >::convert(), YACS::ENGINE::convertFromYacsSequence< CORBAImpl, CORBA::Any * >::convert(), and YACS::ENGINE::CorbaPySequence::CorbaPySequence().

getFromNS()

CORBA::Object_var RuntimeSALOME::getFromNS

(

const char *

entry

)

const

Retrieve from custom NS the entry. Custom NS is supposed to be hosted in current process. This method try to emulate CORBA ns convention : "corbaname:rir:#test.my_context/Echo.Object" is converted into "Echo"

See Engines::EmbeddedNamingService

Definition at line 1920 of file RuntimeSALOME.cxx.

{
  CORBA::Object_var ret;
  std::string entryCpp(entry);
  if(entryCpp.substr(0,4) == "IOR:")
  {
    ret = _orb->string_to_object( entry );
  }
  else
  {
    auto pos = entryCpp.find_last_of('/');
    std::string entry1( entryCpp.substr(pos+1,std::string::npos) );
    pos = entry1.find_last_of('.');
    std::string entry2( entry1.substr(0,pos) );
    Engines::EmbeddedNamingService_var ns = GetEmbeddedNamingService();
    std::unique_ptr<Engines::IORType> iorRet( ns->Resolve( entry2.c_str() ) );
    auto len = iorRet->length();
    std::unique_ptr<char[]> iorTrans(new char[len+1]); iorTrans[len] = '\0';
    for(auto i = 0 ; i < len ; ++i) iorTrans[i] = (*iorRet)[i];
    ret = _orb->string_to_object(iorTrans.get());
  }
  return ret;
}

References yacsorb.CORBAEngineTest::i.

Referenced by YACS::ENGINE::convertFromYacsObjref< PYTHONImpl, PyObject * >::convert(), YACS::ENGINE::convertFromYacsObjref< CORBAImpl, CORBA::Any * >::convert(), and YACS::ENGINE::CORBAComponent::load().

getNS()

std::unique_ptr< SALOME_NamingService_Container_Abstract > RuntimeSALOME::getNS

(

)

Definition at line 138 of file RuntimeSALOME.cxx.

{
  std::unique_ptr<SALOME_NamingService_Container_Abstract> ret(new SALOME_NamingService_Wrapper);
  return ret;
}

getOrb()

CORBA::ORB_ptr RuntimeSALOME::getOrb

(

)

const

Definition at line 1909 of file RuntimeSALOME.cxx.

{
  return _orb;
}

Referenced by YACS::ENGINE::convertToYacsObjref< CORBAImpl, CORBA::Any *, void *, IMPLOUT, TOUT >::convert(), YACS::ENGINE::convertFromYacsStruct< CORBAImpl, CORBA::Any * >::convert(), YACS::ENGINE::convertFromYacsObjref< NEUTRALImpl, YACS::ENGINE::Any * >::convert(), YACS::ENGINE::convertFromYacsSequence< CORBAImpl, CORBA::Any * >::convert(), YACS::HMI::GenericGui::GenericGui(), YACS::ENGINE::getCorbaTCObjref(), YACS::ENGINE::getCorbaTCSequence(), YACS::ENGINE::getCorbaTCStruct(), YACS::HMI::GenericGui::getMachineList(), YACS::ENGINE::SalomeContainerTools::getResourceProperties(), YACS::HMI::BatchJobsListDialog::getSalomeLauncher(), YACS::ENGINE::InputCorbaPort::InputCorbaPort(), YACS::ENGINE::SessionCataLoader::loadCata(), main(), YACS::ENGINE::OutputCorbaPort::OutputCorbaPort(), YACS::ENGINE::InputStudyPort::putDataInStudy(), YACS::ENGINE::PyCorbaObjref::PyCorbaObjref(), shutdownServers(), and YACS::HMI::GuiExecutor::startResumeDataflow().

getPyOrb()

PyObject * RuntimeSALOME::getPyOrb

(

)

const

Definition at line 1944 of file RuntimeSALOME.cxx.

{
  return _pyorb;
}

Referenced by YACS::ENGINE::PyCorbaObjref::PyCorbaObjref().

getSingleton()

static Runtime* YACS::ENGINE::RuntimeSALOME::getSingleton ( )

inlinestaticprivate

Definition at line 60 of file RuntimeSALOME.hxx.

{ return Runtime::_singleton; }

References YACS::ENGINE::Runtime::_singleton.

getVersion()

std::string RuntimeSALOME::getVersion ( ) const

virtual

Definition at line 561 of file RuntimeSALOME.cxx.

{
#ifdef YACS_DEVELOPMENT
  return CORBA::string_dup(YACS_VERSION_STR"dev");
#else
  return CORBA::string_dup(YACS_VERSION_STR);
#endif
}

init()

void RuntimeSALOME::init ( long  flags, int  argc, char *  argv[]  )

virtual

CORBA and Python initialization.

Parameters

flags	contains several bits bit0 (ispyext) true when method is called from Python (Python initialization must not be done!) bit1 (UsePython) true if python nodes are needed bit1 (UseCorba) true if CORBA nodes are needed bit1 (UseXml) true if python nodes are needed bit1 (UseCpp) true if C++ nodes are needed bit1 (UseSalome) true if Salome nodes are needed
argc	number of command line arguments (used to initialize the Python interpreter)
argv	command line arguments (used to initialize the Python interpreter)

Definition at line 280 of file RuntimeSALOME.cxx.

{
  bool ispyext = flags & RuntimeSALOME::IsPyExt;
  if (_useCorba)
    {
      PortableServer::POA_var root_poa;
      PortableServer::POAManager_var pman;
      CORBA::Object_var obj;
      int nbargs = 0; char **args = 0;
      _orb = CORBA::ORB_init (nbargs, args);
      obj = _orb->resolve_initial_references("RootPOA");
      root_poa = PortableServer::POA::_narrow(obj);
      pman = root_poa->the_POAManager();
      pman->activate();
 
#ifdef REFCNT
      DEBTRACE("_orb refCount: " << ((omniOrbORB*)_orb.in())->pd_refCount);
#endif
      obj = _orb->resolve_initial_references("DynAnyFactory");
      _dynFactory = DynamicAny::DynAnyFactory::_narrow(obj);
    }
 
  if (_usePython)
    {
      DEBTRACE("RuntimeSALOME::init, is python extension = " << ispyext);
 
      // Initialize Python interpreter in embedded mode
      if (!Py_IsInitialized())
        {
#if PY_VERSION_HEX < 0x02040000 // python version earlier than 2.4.0
          Py_Initialize(); 
#else
          Py_InitializeEx(0); // do not install signal handlers
#endif
          if (argc > 0 && argv != NULL)
            {
              wchar_t **changed_argv = new wchar_t*[argc];
              for (int i = 0; i < argc; i++)
              {
                changed_argv[i] = Py_DecodeLocale(argv[i], NULL);
              }
              PySys_SetArgv(argc, changed_argv);
            } 
          else
            {
              int pyArgc = 1;
              char* pyArgv[1];
              char defaultName[] = "SALOME_YACS_RUNTIME";
              wchar_t **changed_pyArgv = new wchar_t*[pyArgc];
              pyArgv[0] = defaultName;
              for (int i = 0; i < pyArgc; i++)
              {
                changed_pyArgv[i] = Py_DecodeLocale(pyArgv[i], NULL);
              }
              PySys_SetArgv(pyArgc, changed_pyArgv);
            }
#if PY_VERSION_HEX < 0x03070000
          PyEval_InitThreads(); /* Create (and acquire) the interpreter lock (for threads)*/
#endif
          PyEval_SaveThread(); /* Release the thread state */
          //here we do not have the Global Interpreter Lock
        }
 
      PyObject *mainmod,*pyapi,*res ;
      PyObject *globals;
      PyGILState_STATE gstate;
      gstate = PyGILState_Ensure(); // acquire the Global Interpreter Lock
    
      mainmod = PyImport_AddModule("__main__");
      globals = PyModule_GetDict(mainmod);
      /* globals is a borrowed reference */
  
      if (PyDict_GetItemString(globals, "__builtins__") == NULL) 
        {
          PyObject *bimod = PyImport_ImportModule("builtins");
          if (bimod == NULL || PyDict_SetItemString(globals, "__builtins__", bimod) != 0)
            Py_FatalError("can't add __builtins__ to __main__");
          Py_DECREF(bimod);
        }
 
      _bltins = PyEval_GetBuiltins();  /* borrowed ref */
 
      if (_useCorba)
        {
 
          //init section
          _omnipy = PyImport_ImportModule((char*)"_omnipy");
          if (!_omnipy)
            {
              PyErr_Print();
              PyErr_SetString(PyExc_ImportError, (char*)"Cannot import _omnipy");
              goto out;
            }
          pyapi = PyObject_GetAttrString(_omnipy, (char*)"API");
          if (!pyapi)
            {
              goto out;
            }
          _api = (omniORBpyAPI*)PyCapsule_GetPointer(pyapi,"_omnipy.API");
          Py_DECREF(pyapi);
 
          res=PyRun_String("\n"
                           "from math import *\n"
                           "import sys\n"
                           "sys.path.insert(0,'.')\n"
                           "from omniORB import CORBA\n"
                           "from omniORB import any\n"
                           "orb = CORBA.ORB_init([], CORBA.ORB_ID)\n"
                           "#print(sys.getrefcount(orb))\n"
                           "try:\n"
                           "  import SALOME\n"
                           "except:\n"
                           "  pass\n"
                           "\n",
                           Py_file_input,globals,globals );
          if(res == NULL)
            {
              PyErr_Print();
              goto out;
            }
          Py_DECREF(res);
 
          _pyorb = PyDict_GetItemString(globals,"orb");
          /* PyDict_GetItemString returns a borrowed reference. There is no need to decref _pyorb */
 
          PyObject *pyany;
          pyany = PyDict_GetItemString(globals,"any");
          /* PyDict_GetItemString returns a borrowed reference. There is no need to decref pyany */
 
#ifdef REFCNT
          DEBTRACE("_orb refCount: " << ((omniOrbORB*)_orb.in())->pd_refCount);
#endif
        }
      out:
        PyGILState_Release(gstate); // Release the Global Interpreter Lock
    }
  if (_useCorba)
    {
      // initialize the catalogLoaderFactory map with the session one
      _catalogLoaderFactoryMap["session"]=new SessionCataLoader;
    }
}

References driver_internal::args, DEBTRACE, yacsorb.CORBAEngineTest::i, and Py_DecodeLocale().

initBuiltins()

void RuntimeSALOME::initBuiltins ( )

protected

Definition at line 170 of file RuntimeSALOME.cxx.

{
  //Fill the builtin catalog with nodes specific to the runtime
  std::map<std::string,TypeCode*>& typeMap=_builtinCatalog->_typeMap;
  std::map<std::string,Node*>& nodeMap=_builtinCatalog->_nodeMap;
  std::map<std::string,ComposedNode*>& composednodeMap=_builtinCatalog->_composednodeMap;
  std::map<std::string,ComponentDefinition*>& componentMap=_builtinCatalog->_componentMap;
  nodeMap["PyFunction"]=new PyFuncNode("PyFunction");
  nodeMap["PyScript"]=new PythonNode("PyScript");
  nodeMap["CORBANode"]=new CORBANode("CORBANode");
  nodeMap["XmlNode"]=new XmlNode("XmlNode");
  nodeMap["SalomeNode"]=new SalomeNode("SalomeNode");
  nodeMap["CppNode"]=new CppNode("CppNode");
  nodeMap["SalomePythonNode"]=new SalomePythonNode("SalomePythonNode");
  nodeMap["PresetNode"]=new PresetNode("PresetNode");
  nodeMap["OutNode"]=new OutNode("OutNode");
  nodeMap["StudyInNode"]=new StudyInNode("StudyInNode");
  nodeMap["StudyOutNode"]=new StudyOutNode("StudyOutNode");
  composednodeMap["OptimizerLoop"]=createOptimizerLoop("OptimizerLoop","","",true);
  typeMap["dblevec"]= createSequenceTc("dblevec","dblevec",_tc_double);
  typeMap["intvec"]= createSequenceTc("intvec","intvec",_tc_int);
  typeMap["stringvec"]= createSequenceTc("stringvec","stringvec",_tc_string);
  typeMap["boolvec"]= createSequenceTc("boolvec","boolvec",_tc_bool);
  typeMap["seqdblevec"]= createSequenceTc("seqdblevec","seqdblevec",typeMap["dblevec"]);
  typeMap["seqintvec"]= createSequenceTc("seqintvec","seqintvec",typeMap["intvec"]);
  typeMap["seqstringvec"]= createSequenceTc("seqstringvec","seqstringvec",typeMap["stringvec"]);
  typeMap["seqboolvec"]= createSequenceTc("seqboolvec","seqboolvec",typeMap["boolvec"]);
  std::list<TypeCodeObjref *> ltc;
  typeMap["pyobj"]= createInterfaceTc("python:obj:1.0","pyobj",ltc);
  typeMap["seqpyobj"]= createSequenceTc("seqpyobj","seqpyobj",typeMap["pyobj"]);
  composednodeMap["Bloc"]=createBloc("Bloc");
  composednodeMap["Switch"]=createSwitch("Switch");
  composednodeMap["WhileLoop"]=createWhileLoop("WhileLoop");
  composednodeMap["ForLoop"]=createForLoop("ForLoop");
  composednodeMap["ForEachLoop_double"]=createForEachLoop("ForEachLoop_double",Runtime::_tc_double);
  composednodeMap["ForEachLoop_string"]=createForEachLoop("ForEachLoop_string",Runtime::_tc_string);
  composednodeMap["ForEachLoop_int"]=createForEachLoop("ForEachLoop_int",Runtime::_tc_int);
  composednodeMap["ForEachLoop_bool"]=createForEachLoop("ForEachLoop_bool",Runtime::_tc_bool);
  composednodeMap["ForEachLoop_pyobj"]=createForEachLoop("ForEachLoop_pyobj",typeMap["pyobj"]);;
  ENGINE::TypeCodeStruct *t = createStructTc("","Engines/dataref");
  t->addMember("ref",_tc_string);
  typeMap["dataref"]= t;
}

References gui.Appli::t.

launchSubProcess()

PyObject * RuntimeSALOME::launchSubProcess

(

const std::vector< std::string > &

cmds

)

Definition at line 471 of file RuntimeSALOME.cxx.

{
  std::ostringstream oss; oss << "from subprocess import Popen" << std::endl;
  oss << "p = Popen([";
  for(auto i = 0 ; i < cmds.size() ; ++i)
  {
    oss << " " << "\"" << cmds[i] << "\"";
    if(i < cmds.size()-1)
      oss << ", ";
    else
      oss << " ";
  }
  oss << "])";
  AutoGIL agil;
  AutoPyRef context = PyDict_New();
  PyDict_SetItemString( context, "__builtins__", getBuiltins() );
  std::string errorDetails;
  try
  {
    PythonNode::ExecuteLocalInternal(oss.str().c_str(),context,errorDetails);
  }
  catch(const YACS::Exception& e)
  {
    std::cerr << e.what() << std::endl << errorDetails << std::endl;
    throw e;
  }
  PyObject *ret = PyDict_GetItemString(context,"p");
  Py_XINCREF(ret);
  Py_XINCREF(ret);
  return ret;
}

References yacsorb.CORBAEngineTest::i, and YACS::Exception::what().

loadModulCatalog()

void RuntimeSALOME::loadModulCatalog

(

)

Definition at line 256 of file RuntimeSALOME.cxx.

{
  AutoGIL agil;
  const char * SCRIPT = "from salome_kernel import list_of_catalogs_regarding_environement\n"
"import KernelModuleCatalog\n"
"KernelModuleCatalog.myModuleCatalog( list_of_catalogs_regarding_environement() )\n";
  PyRun_SimpleString(SCRIPT);
}

Referenced by main(), and shutdownServers().

setRuntime()

void RuntimeSALOME::setRuntime ( long  flags = UsePython+UseCorba+UseXml+UseCpp+UseSalome, int  argc = 0, char *  argv[] = NULL  )

static

Definition at line 144 of file RuntimeSALOME.cxx.

{
  if (! Runtime::_singleton)
    {
      RuntimeSALOME* r=new RuntimeSALOME(flags, argc, argv);
      Runtime::_singleton = r;
      r->initBuiltins();
    }
  DEBTRACE("RuntimeSALOME::setRuntime() done !");
}

References DEBTRACE, and testCppPluginInvokation::r.

Referenced by driverTest(), YACS::HMI::GenericGui::GenericGui(), and main().

Friends And Related Function Documentation

getSALOMERuntime

RuntimeSALOME* getSALOMERuntime ( )

friend

Member Data Documentation

_api

omniORBpyAPI* YACS::ENGINE::RuntimeSALOME::_api

protected

Definition at line 256 of file RuntimeSALOME.hxx.

_bltins

PyObject* YACS::ENGINE::RuntimeSALOME::_bltins

protected

Definition at line 254 of file RuntimeSALOME.hxx.

_connectionManager

ConnectionManager YACS::ENGINE::RuntimeSALOME::_connectionManager

private

Definition at line 262 of file RuntimeSALOME.hxx.

_dynFactory

DynamicAny::DynAnyFactory_var YACS::ENGINE::RuntimeSALOME::_dynFactory

protected

Definition at line 255 of file RuntimeSALOME.hxx.

_flags

long YACS::ENGINE::RuntimeSALOME::_flags

protected

Definition at line 258 of file RuntimeSALOME.hxx.

_omnipy

PyObject* YACS::ENGINE::RuntimeSALOME::_omnipy

protected

Definition at line 257 of file RuntimeSALOME.hxx.

_orb

CORBA::ORB_var YACS::ENGINE::RuntimeSALOME::_orb

protected

Definition at line 252 of file RuntimeSALOME.hxx.

_pyorb

PyObject* YACS::ENGINE::RuntimeSALOME::_pyorb

protected

Definition at line 253 of file RuntimeSALOME.hxx.

_useCorba

bool YACS::ENGINE::RuntimeSALOME::_useCorba

protected

Definition at line 259 of file RuntimeSALOME.hxx.

_useCpp

bool YACS::ENGINE::RuntimeSALOME::_useCpp

protected

Definition at line 259 of file RuntimeSALOME.hxx.

_usePython

bool YACS::ENGINE::RuntimeSALOME::_usePython

protected

Definition at line 259 of file RuntimeSALOME.hxx.

_useXml

bool YACS::ENGINE::RuntimeSALOME::_useXml

protected

Definition at line 259 of file RuntimeSALOME.hxx.

enum { ... } YACS::ENGINE::RuntimeSALOME::FLAGS

---

The documentation for this class was generated from the following files:

• src/runtime/RuntimeSALOME.hxx
• src/runtime/RuntimeSALOME.cxx