Version: 8.3.0
RuntimeSALOME.hxx
Go to the documentation of this file.
1 // Copyright (C) 2006-2016 CEA/DEN, EDF R&D
2 //
3 // This library is free software; you can redistribute it and/or
4 // modify it under the terms of the GNU Lesser General Public
5 // License as published by the Free Software Foundation; either
6 // version 2.1 of the License, or (at your option) any later version.
7 //
8 // This library is distributed in the hope that it will be useful,
9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11 // Lesser General Public License for more details.
12 //
13 // You should have received a copy of the GNU Lesser General Public
14 // License along with this library; if not, write to the Free Software
15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
16 //
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
18 //
19 
20 #ifndef _RUNTIMESALOME_HXX_
21 #define _RUNTIMESALOME_HXX_
22 
23 #include "YACSRuntimeSALOMEExport.hxx"
24 
25 // rnv: avoid compilation warning on Linux : "_POSIX_C_SOURCE" and "_XOPEN_SOURCE" are redefined
26 #ifdef _POSIX_C_SOURCE
27 #undef _POSIX_C_SOURCE
28 #endif
29 
30 #ifdef _XOPEN_SOURCE
31 #undef _XOPEN_SOURCE
32 #endif
33 
34 #include <Python.h>
35 #include <omniORB4/CORBA.h>
36 #include "Runtime.hxx"
37 
38 #include<string>
39 #include<set>
40 
41 //--- from omniORBpy.h (not present on Debian Sarge packages)
42 struct omniORBpyAPI
43 {
44  PyObject* (*cxxObjRefToPyObjRef)(const CORBA::Object_ptr cxx_obj,
45  CORBA::Boolean hold_lock);
46  // Convert a C++ object reference to a Python object reference.
47  // If <hold_lock> is true, caller holds the Python interpreter lock.
48 
49  CORBA::Object_ptr (*pyObjRefToCxxObjRef)(PyObject* py_obj,
50  CORBA::Boolean hold_lock);
51  // Convert a Python object reference to a C++ object reference.
52  // Raises BAD_PARAM if the Python object is not an object reference.
53  // If <hold_lock> is true, caller holds the Python interpreter lock.
54 
55  PyObject* (*handleCxxSystemException)(const CORBA::SystemException& ex);
56  // Sets the Python exception state to reflect the given C++ system
57  // exception. Always returns NULL. The caller must hold the Python
58  // interpreter lock.
59 };
60 //--- end of from omniORBpy.h (not present on Debian Sarge packages)
61 
62 namespace YACS
63 {
64  namespace ENGINE
65  {
66 
67  class RuntimeSALOME;
68  YACSRUNTIMESALOME_EXPORT RuntimeSALOME* getSALOMERuntime();
69 
70  class InputCorbaPort;
71  class InputPyPort;
72  class InputXmlPort;
73  class InputCppPort;
74 
75  class YACSRUNTIMESALOME_EXPORT RuntimeSALOME: public Runtime
76  {
77  static Runtime* getSingleton() { return Runtime::_singleton; }
78 
79  public:
80 
81  enum
82  {
83  IsPyExt = 1,
84  UsePython = 2,
85  UseCorba = 4,
86  UseXml = 8,
87  UseCpp = 16,
88  UseSalome = 32
89  } FLAGS;
90 
91  // singleton creation
92  static void setRuntime(long flags = UsePython+UseCorba+UseXml+UseCpp+UseSalome,
93  int argc = 0, char* argv[] = NULL);
94 
95  friend RuntimeSALOME* getSALOMERuntime();
96 
97  virtual std::string getVersion() const;
98 
99  virtual void init(long flags, int argc, char* argv[]);
100  virtual void fini();
101 
102  virtual InputPort* createInputPort(const std::string& name,
103  const std::string& impl,
104  Node * node,
105  TypeCode * type);
106 
107  virtual OutputPort* createOutputPort(const std::string& name,
108  const std::string& impl,
109  Node * node,
110  TypeCode * type);
111  virtual InputDataStreamPort* createInputDataStreamPort(const std::string& name,
112  Node *node,TypeCode *type);
113 
114  virtual OutputDataStreamPort* createOutputDataStreamPort(const std::string& name,
115  Node *node,TypeCode *type);
116 
117  virtual DataNode* createInDataNode(const std::string& kind,const std::string& name);
118  virtual DataNode* createOutDataNode(const std::string& kind,const std::string& name);
119  virtual InlineFuncNode* createFuncNode(const std::string& kind,const std::string& name);
120  virtual InlineNode* createScriptNode(const std::string& kind,const std::string& name);
121 
122  virtual ServiceNode* createRefNode(const std::string& kind,const std::string& name);
123  virtual ServiceNode* createCompoNode(const std::string& kind,const std::string& name);
124  virtual ServiceInlineNode *createSInlineNode(const std::string& kind, const std::string& name);
125  virtual ComponentInstance* createComponentInstance(const std::string& name,
126  const std::string& kind="");
127  virtual Container *createContainer(const std::string& kind="");
128  virtual WhileLoop* createWhileLoop(const std::string& name);
129  virtual ForLoop* createForLoop(const std::string& name);
130  virtual OptimizerLoop* createOptimizerLoop(const std::string& name,const std::string& algLib,
131  const std::string& factoryName,bool algInitOnFile,
132  const std::string& kind="", Proc * procForTypes = NULL);
133  virtual Bloc* createBloc(const std::string& name);
134  virtual Proc* createProc(const std::string& name);
135 
136  virtual TypeCode * createInterfaceTc(const std::string& id, const std::string& name,
137  std::list<TypeCodeObjref *> ltc);
138  virtual TypeCode * createSequenceTc(const std::string& id, const std::string& name, TypeCode *content);
139  virtual TypeCodeStruct * createStructTc(const std::string& id, const std::string& name);
140 
141  virtual InputPort* adapt(InputPort* source,
142  const std::string& impl,
143  TypeCode * type,bool init=false) throw (ConversionException);
144 
145  virtual InputPort* adapt(InPropertyPort* source,
146  const std::string& impl,
147  TypeCode * type,bool init=false) throw (ConversionException);
148 
149  virtual InputPort* adaptNeutral(InputPort* source,
150  const std::string& impl,
151  TypeCode * type,bool init) throw (ConversionException);
152 
153  virtual InputPort* adapt(InputCorbaPort* source,
154  const std::string& impl,
155  TypeCode * type,bool init) throw (ConversionException);
156 
157  virtual InputPort* adaptCorbaToCorba(InputCorbaPort* source,
158  TypeCode * type) throw (ConversionException);
159 
160  virtual InputPort* adaptCorbaToNeutral(InputCorbaPort* source,
161  TypeCode * type) throw (ConversionException);
162 
163  virtual InputPort* adaptCorbaToPython(InputCorbaPort* source,
164  TypeCode * type) throw (ConversionException);
165 
166  virtual InputPort* adaptCorbaToCpp(InputCorbaPort* source,
167  TypeCode * type) throw (ConversionException);
168 
169  virtual InputPort* adaptCorbaToXml(InputCorbaPort* source,
170  TypeCode * type) throw (ConversionException);
171 
172  virtual InputPort* adapt(InputPyPort* source,
173  const std::string& impl,
174  TypeCode * type,bool init) throw (ConversionException);
175 
176  virtual InputPort* adaptPythonToCorba(InputPyPort* source,
177  TypeCode * type) throw (ConversionException);
178 
179  virtual InputPort* adaptPythonToNeutral(InputPyPort* source,
180  TypeCode * type) throw (ConversionException);
181 
182  virtual InputPort* adaptPythonToPython(InputPyPort* source,
183  TypeCode * type,bool init) throw (ConversionException);
184 
185  virtual InputPort* adaptPythonToXml(InputPyPort* source,
186  TypeCode * type) throw (ConversionException);
187 
188  virtual InputPort* adaptPythonToCpp(InputPyPort* source,
189  TypeCode * type) throw (ConversionException);
190 
191  virtual InputPort* adapt(InputCppPort* source,
192  const std::string& impl,
193  TypeCode * type,bool init) throw (ConversionException);
194 
195  virtual InputPort* adaptCppToCorba(InputCppPort* source,
196  TypeCode * type) throw (ConversionException);
197 
198  virtual InputPort* adaptCppToNeutral(InputCppPort* source,
199  TypeCode * type) throw (ConversionException);
200 
201  virtual InputPort* adaptCppToPython(InputCppPort* source,
202  TypeCode * type) throw (ConversionException);
203 
204  virtual InputPort* adaptCppToXml(InputCppPort* source,
205  TypeCode * type) throw (ConversionException);
206 
207  virtual InputPort* adaptCppToCpp(InputCppPort* source,
208  TypeCode * type) throw (ConversionException);
209 
210  virtual InputPort* adapt(InputXmlPort* source,
211  const std::string& impl,
212  TypeCode * type,bool init) throw (ConversionException);
213 
214  virtual InputPort* adaptXmlToCorba(InputXmlPort* source,
215  TypeCode * type) throw (ConversionException);
216 
217  virtual InputPort* adaptXmlToPython(InputXmlPort* inport,
218  TypeCode * type) throw (ConversionException);
219 
220  virtual InputPort* adaptXmlToCpp(InputXmlPort* inport,
221  TypeCode * type) throw (ConversionException);
222 
223  virtual InputPort* adaptXmlToNeutral(InputXmlPort* inport,
224  TypeCode * type) throw (ConversionException);
225  virtual InputPort* adaptXmlToXml(InputXmlPort* inport,
226  TypeCode * type,bool init) throw (ConversionException);
227 
228 
229  virtual InputPort* adaptNeutralToXml(InputPort* inport,
230  TypeCode * type) throw (ConversionException);
231 
232  virtual InputPort* adaptNeutralToPython(InputPort* inport,
233  TypeCode * type) throw (ConversionException);
234 
235  virtual InputPort* adaptNeutralToCorba(InputPort* inport,
236  TypeCode * type) throw (ConversionException);
237 
238  virtual InputPort* adaptNeutralToCpp(InputPort* inport,
239  TypeCode * type) throw (ConversionException);
240 
241  virtual void* convertNeutral(TypeCode * type, Any *data);
242  virtual std::string convertNeutralAsString(TypeCode * type, Any *data);
243  virtual std::string convertPyObjectToString(PyObject* ob);
244  virtual PyObject* convertStringToPyObject(const std::string& s);
245 
246  virtual ~RuntimeSALOME();
247 
248  CORBA::ORB_ptr getOrb();
249  PyObject * getPyOrb();
250  PyObject * getBuiltins();
251  DynamicAny::DynAnyFactory_ptr getDynFactory();
252  omniORBpyAPI* getApi();
253  PyObject * get_omnipy();
254 
255  protected:
256  RuntimeSALOME(); // singleton
257  RuntimeSALOME(long flags, int argc, char* argv[]); // singleton
258  void initBuiltins();
259  CORBA::ORB_var _orb;
260  PyObject * _pyorb;
261  PyObject * _bltins;
262  DynamicAny::DynAnyFactory_var _dynFactory;
263  omniORBpyAPI* _api;
264  PyObject* _omnipy;
265  long _flags;
266  bool _usePython, _useCorba, _useCpp, _useXml;
267 
268  };
269  }
270 }
271 
272 #endif