1 // Copyright (C) 2006-2020 CEA/DEN, EDF R&D
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
27 // ----------------------------------------------------------------------------
30 #include "yacsconfig.h"
33 #include <omniORB4/CORBA.h>
35 #include <omniORBpy.h>
38 #define OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS \
39 catch (const CORBA::SystemException& ex) { \
40 return api->handleCxxSystemException(ex); \
43 #define OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
47 #include "InlineNode.hxx"
48 #include "ComposedNode.hxx"
49 #include "ServiceNode.hxx"
50 #include "ServiceInlineNode.hxx"
51 #include "ServerNode.hxx"
54 #include "ForLoop.hxx"
55 #include "WhileLoop.hxx"
56 #include "ForEachLoop.hxx"
58 #include "InputPort.hxx"
59 #include "OutputPort.hxx"
60 #include "InPropertyPort.hxx"
61 #include "InputDataStreamPort.hxx"
62 #include "OutputDataStreamPort.hxx"
63 #include "OptimizerLoop.hxx"
64 #include "HomogeneousPoolContainer.hxx"
65 #include "IteratorPy3.hxx"
69 class InterpreterUnlocker
74 _save = PyEval_SaveThread(); // allow Python threads to run
76 ~InterpreterUnlocker()
78 PyEval_RestoreThread(_save); // restore the thread state
84 static PyObject* convertNode(YACS::ENGINE::Node* node,int owner=0)
87 return SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Node,owner);
89 //should use $descriptor(YACS::ENGINE::Bloc *) and so on but $descriptor is not defined here
90 // It is better to define a helper function to avoid code bloat
91 // First try to find a swig type info by its mangled name
92 std::string swigtypename="_p_"+node->typeName();
93 swig_type_info *ret = SWIG_MangledTypeQuery(swigtypename.c_str());
95 ob=SWIG_NewPointerObj((void*)node,ret,owner);
98 //typeName not known by swig. Try dynamic_cast on known classes
99 //You must respect inheritance order in casting : Bloc before ComposedNode and so on
100 if(dynamic_cast<YACS::ENGINE::Proc *>(node))
101 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Proc,owner);
102 else if(dynamic_cast<YACS::ENGINE::Bloc *>(node))
103 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Bloc,owner);
104 else if(dynamic_cast<YACS::ENGINE::ForLoop *>(node))
105 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ForLoop,owner);
106 else if(dynamic_cast<YACS::ENGINE::WhileLoop *>(node))
107 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__WhileLoop,owner);
108 else if(dynamic_cast<YACS::ENGINE::ForEachLoop *>(node))
109 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ForEachLoop,owner);
110 else if(dynamic_cast<YACS::ENGINE::Switch *>(node))
111 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Switch,owner);
112 else if(dynamic_cast<YACS::ENGINE::ComposedNode *>(node))
113 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ComposedNode,owner);
114 else if(dynamic_cast<YACS::ENGINE::InlineFuncNode *>(node))
115 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__InlineFuncNode,owner);
116 else if(dynamic_cast<YACS::ENGINE::InlineNode *>(node))
117 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__InlineNode,owner);
118 else if(dynamic_cast<YACS::ENGINE::ServiceInlineNode *>(node))
119 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ServiceInlineNode,owner);
120 else if(dynamic_cast<YACS::ENGINE::ServiceNode *>(node))
121 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ServiceNode,owner);
122 else if(dynamic_cast<YACS::ENGINE::ServerNode *>(node))
123 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ServerNode,owner);
124 else if(dynamic_cast<YACS::ENGINE::ElementaryNode *>(node))
125 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ElementaryNode,owner);
127 ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Node,owner);
132 static PyObject* convertPort(YACS::ENGINE::Port* port,int owner=0)
135 return SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__Port, owner);
137 std::string swigtypename="_p_"+port->typeName();
138 swig_type_info *ret = SWIG_MangledTypeQuery(swigtypename.c_str());
141 YACS::ENGINE::InPropertyPort *inpropertyport = dynamic_cast<YACS::ENGINE::InPropertyPort*>(port);
143 return SWIG_NewPointerObj((void*)inpropertyport,ret,owner);
145 YACS::ENGINE::InputPort *inport = dynamic_cast<YACS::ENGINE::InputPort *>(port);
147 return SWIG_NewPointerObj((void*)inport,ret,owner);
149 YACS::ENGINE::OutputPort *outport = dynamic_cast<YACS::ENGINE::OutputPort *>(port);
151 return SWIG_NewPointerObj((void*)outport,ret,owner);
153 YACS::ENGINE::InputDataStreamPort *indsport = dynamic_cast<YACS::ENGINE::InputDataStreamPort *>(port);
155 return SWIG_NewPointerObj((void*)indsport,ret,owner);
157 YACS::ENGINE::OutputDataStreamPort *outdsport = dynamic_cast<YACS::ENGINE::OutputDataStreamPort *>(port);
159 return SWIG_NewPointerObj((void*)outdsport,ret,owner);
161 return SWIG_NewPointerObj((void*)port,ret,owner);
165 if(YACS::ENGINE::AnyInputPort *cport =dynamic_cast<YACS::ENGINE::AnyInputPort *>(port))
166 ob=SWIG_NewPointerObj((void*)cport,SWIGTYPE_p_YACS__ENGINE__AnyInputPort,owner);
167 else if(YACS::ENGINE::AnyOutputPort *cport =dynamic_cast<YACS::ENGINE::AnyOutputPort *>(port))
168 ob=SWIG_NewPointerObj((void*)cport,SWIGTYPE_p_YACS__ENGINE__AnyOutputPort,owner);
169 else if(dynamic_cast<YACS::ENGINE::InPropertyPort*>(port))
170 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InPropertyPort,owner);
171 else if(dynamic_cast<YACS::ENGINE::InputPort *>(port))
172 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InputPort,owner);
173 else if(dynamic_cast<YACS::ENGINE::OutputPort *>(port))
174 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutputPort,owner);
175 else if(dynamic_cast<YACS::ENGINE::InputDataStreamPort *>(port))
176 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InputDataStreamPort, owner);
177 else if(dynamic_cast<YACS::ENGINE::OutputDataStreamPort *>(port))
178 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutputDataStreamPort, owner);
179 else if(dynamic_cast<YACS::ENGINE::InPort *>(port))
180 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InPort, owner);
181 else if(dynamic_cast<YACS::ENGINE::OutPort *>(port))
182 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutPort, owner);
183 else if(dynamic_cast<YACS::ENGINE::InGate *>(port))
184 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InGate, owner);
185 else if(dynamic_cast<YACS::ENGINE::OutGate *>(port))
186 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutGate, owner);
188 ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__Port, owner);
193 static PyObject *convertContainer(YACS::ENGINE::Container *cont, int owner=0)
196 return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
197 if(dynamic_cast<YACS::ENGINE::HomogeneousPoolContainer *>(cont))
199 return SWIG_NewPointerObj((void*)dynamic_cast<YACS::ENGINE::HomogeneousPoolContainer *>(cont),SWIGTYPE_p_YACS__ENGINE__HomogeneousPoolContainer, owner);
201 return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
204 //convertFromPyObjVectorOfObj<YACS::ENGINE::SequenceAny *>(pyLi,SWIGTYPE_p_YACS__ENGINE__SequenceAny,"SequenceAny")
206 static void convertFromPyObjVectorOfObj(PyObject *pyLi, swig_type_info *ty, const char *typeStr, typename std::vector<T>& ret)
209 if(PyList_Check(pyLi))
211 int size=PyList_Size(pyLi);
213 for(int i=0;i<size;i++)
215 PyObject *obj=PyList_GetItem(pyLi,i);
216 int status=SWIG_ConvertPtr(obj,&argp,ty,0|0);
217 if(!SWIG_IsOK(status))
219 std::ostringstream oss; oss << "convertFromPyObjVectorOfObj : list is excepted to contain only " << typeStr << " instances !";
220 throw YACS::Exception(oss.str());
222 T arg=reinterpret_cast< T >(argp);
226 else if(PyTuple_Check(pyLi))
228 int size=PyTuple_Size(pyLi);
230 for(int i=0;i<size;i++)
232 PyObject *obj=PyTuple_GetItem(pyLi,i);
233 int status=SWIG_ConvertPtr(obj,&argp,ty,0|0);
234 if(!SWIG_IsOK(status))
236 std::ostringstream oss; oss << "convertFromPyObjVectorOfObj : tuple is excepted to contain only " << typeStr << " instances !";
237 throw YACS::Exception(oss.str());
239 T arg=reinterpret_cast< T >(argp);
243 else if(SWIG_IsOK(SWIG_ConvertPtr(pyLi,&argp,ty,0|0)))
246 T arg=reinterpret_cast< T >(argp);
250 throw YACS::Exception("convertFromPyObjVectorOfObj : not a list nor a tuple");
255 // ----------------------------------------------------------------------------
257 #if SWIG_VERSION >= 0x010329
258 %template() std::list<int>;
259 %template() std::list<std::string>;
263 %typemap(out) std::list<int>
266 std::list<int>::iterator iL;
268 $result = PyList_New($1.size());
269 for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
270 PyList_SetItem($result,i,PyLong_FromLong((*iL)));
273 %typemap(out) std::list<std::string>
276 std::list<std::string>::iterator iL;
278 $result = PyList_New($1.size());
279 for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
280 PyList_SetItem($result,i,PyUnicode_FromString((*iL).c_str()));
283 %typemap(in) std::list<std::string>
285 /* Check if input is a list */
286 if (PyList_Check($input))
288 int size = PyList_Size($input);
290 std::list<std::string> myList;
292 for (i = 0; i < size; i++)
294 PyObject *o = PyList_GetItem($input,i);
295 if (PyUnicode_Check(o))
296 $1.push_back(std::string(PyUnicode_AsUTF8(PyList_GetItem($input,i))));
299 PyErr_SetString(PyExc_TypeError,"list must contain strings");
306 PyErr_SetString(PyExc_TypeError,"not a list");
313 // ----------------------------------------------------------------------------
317 %typecheck(SWIG_TYPECHECK_POINTER) YACS::ENGINE::Any*
320 if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0) == 0)
322 else if (PyLong_Check($input))
324 else if(PyFloat_Check($input))
326 else if (PyUnicode_Check($input))
328 else if (PyBytes_Check($input))
334 %typemap(in) YACS::ENGINE::Any* (int is_new_object)
336 if ((SWIG_ConvertPtr($input,(void **) &$1, $1_descriptor,SWIG_POINTER_EXCEPTION)) == 0)
338 // It is an Any : it is converted by SWIG_ConvertPtr $input -> $1
341 else if (PyLong_Check($input))
344 $1=YACS::ENGINE::AtomAny::New((int)PyLong_AsLong($input));
347 else if(PyFloat_Check($input))
350 $1=YACS::ENGINE::AtomAny::New(PyFloat_AsDouble($input));
353 else if(PyUnicode_Check($input))
356 $1=YACS::ENGINE::AtomAny::New(PyUnicode_AsUTF8($input));
359 else if(PyBytes_Check($input))
364 PyBytes_AsStringAndSize($input,&pt,&len);
365 $1=YACS::ENGINE::AtomAny::New(std::string(pt,len));
372 PyErr_SetString(PyExc_TypeError,"not a yacs any or a convertible type");
377 %typemap(directorout) YACS::ENGINE::Any*
379 if ((SWIG_ConvertPtr($1,(void **) &$result, $1_descriptor,SWIG_POINTER_EXCEPTION)) == 0)
381 // It is an Any : it is converted by SWIG_ConvertPtr $input -> $1
383 else if (PyInt_Check($1))
386 $result=YACS::ENGINE::AtomAny::New((int)PyLong_AsLong($1));
388 else if(PyFloat_Check($1))
391 $result=YACS::ENGINE::AtomAny::New(PyFloat_AsDouble($1));
393 else if(PyUnicode_Check($1))
396 $result=YACS::ENGINE::AtomAny::New(PyUnicode_AsUTF8($1));
398 else if(PyBytes_Check($1))
403 PyBytes_AsStringAndSize($1,&pt,&len);
404 $result=YACS::ENGINE::AtomAny::New(std::string(pt,len));
409 PyErr_SetString(PyExc_TypeError,"not a yacs any or a convertible type");
414 %typemap(freearg) YACS::ENGINE::Any *inSample
416 //a reference is taken by the routine called
417 if (!is_new_object$argnum) $1->incrRef();
420 %typemap(freearg) YACS::ENGINE::Any*
422 //no reference taken by the routine called
423 if (is_new_object$argnum) $1->decrRef();
426 %typemap(out) YACS::ENGINE::Any*
428 if(dynamic_cast<YACS::ENGINE::SequenceAny *>($1))
429 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__SequenceAny,$owner);
430 else if(dynamic_cast<YACS::ENGINE::ArrayAny *>($1))
431 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__ArrayAny,$owner);
432 else if(dynamic_cast<YACS::ENGINE::StructAny *>($1))
433 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__StructAny,$owner);
435 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__Any,$owner);
438 %typemap(out) YACS::ENGINE::TypeCode*
440 if(dynamic_cast<YACS::ENGINE::TypeCodeStruct *>($1))
441 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCodeStruct,$owner);
442 else if(dynamic_cast<YACS::ENGINE::TypeCodeSeq *>($1))
443 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCodeSeq,$owner);
444 else if(dynamic_cast<YACS::ENGINE::TypeCodeObjref *>($1))
445 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCodeObjref,$owner);
447 $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCode,$owner);
450 %typemap(in) std::list<YACS::ENGINE::TypeCodeObjref*>
452 // Check if input is a list
453 if (PyList_Check($input))
455 int size = PyList_Size($input);
457 std::list<YACS::ENGINE::TypeCodeObjref*> myList;
459 for (i = 0; i < size; i++)
461 PyObject *o = PyList_GetItem($input,i);
462 YACS::ENGINE::TypeCode* temp;
463 if ((SWIG_ConvertPtr(o, (void **) &temp, $descriptor(YACS::ENGINE::TypeCode*),0)) == -1)
465 PyErr_SetString(PyExc_TypeError,"not a YACS::ENGINE::TypeCode*");
470 if(temp->kind() == YACS::ENGINE::Objref)
471 $1.push_back((YACS::ENGINE::TypeCodeObjref*)temp);
474 PyErr_SetString(PyExc_TypeError,"not a YACS::ENGINE::TypeCodeObjref*");
482 PyErr_SetString(PyExc_TypeError,"not a list");
487 %typemap(in) const std::list<YACS::ENGINE::Node *>&
489 if(!PyList_Check($input))
491 PyErr_SetString(PyExc_TypeError,"not a list");
494 $1=new std::list<YACS::ENGINE::Node *>;
495 int size(PyList_Size($input));
496 for(int i=0;i<size;i++)
498 PyObject *o=PyList_GetItem($input,i);
499 YACS::ENGINE::Node *temp(nullptr);
500 if((SWIG_ConvertPtr(o,(void **)&temp, $descriptor(YACS::ENGINE::Node*),0)) == -1)
502 PyErr_SetString(PyExc_TypeError,"not a YACS::ENGINE::TypeCode*");
509 %typemap(out) YACS::ENGINE::Node*
511 $result=convertNode($1,$owner);
514 %typemap(out) YACS::ENGINE::ServiceNode*
516 $result=convertNode($1,$owner);
519 %typemap(out) YACS::ENGINE::InlineNode*
521 $result=convertNode($1,$owner);
524 %typemap(out) YACS::ENGINE::InlineFuncNode*
526 $result=convertNode($1,$owner);
529 %typemap(out) YACS::ENGINE::ComposedNode*
531 $result=convertNode($1,$owner);
534 %typemap(out) YACS::ENGINE::OptimizerLoop*
536 $result=convertNode($1,$owner);
539 %typemap(out) YACS::ENGINE::Proc*
541 $result=convertNode($1,$owner);
544 %typemap(out) std::set<YACS::ENGINE::Node *>
547 std::set<YACS::ENGINE::Node *>::iterator iL;
549 $result = PyList_New($1.size());
551 for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
554 PyList_SetItem($result,i,ob);
558 %typemap(out) std::list<YACS::ENGINE::Node *>
561 std::list<YACS::ENGINE::Node *>::iterator iL;
563 $result = PyList_New($1.size());
565 for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
568 PyList_SetItem($result,i,ob);
572 %typemap(out) YACS::ENGINE::InputPort*,YACS::ENGINE::OutputPort*,YACS::ENGINE::InPort*,YACS::ENGINE::OutPort*,YACS::ENGINE::InPropertyPort*
574 $result=convertPort($1,$owner);
577 %typemap(out) std::set<YACS::ENGINE::InGate *>
580 std::set<YACS::ENGINE::InGate *>::iterator iL;
581 $result = PyList_New($1.size());
583 for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
586 PyList_SetItem($result,i,ob);
590 %typemap(out) std::set<YACS::ENGINE::OutGate *>
593 std::set<YACS::ENGINE::OutGate *>::iterator iL;
594 $result = PyList_New($1.size());
596 for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
599 PyList_SetItem($result,i,ob);
603 %typemap(out) std::set<YACS::ENGINE::InPort *>
605 std::set<YACS::ENGINE::InPort *>::iterator iL;
606 $result = PyList_New(0);
609 for (iL=$1.begin(); iL!=$1.end(); iL++)
612 status=PyList_Append($result,ob);
616 PyErr_SetString(PyExc_TypeError,"cannot build the inport list");
622 %typemap(out) std::set<YACS::ENGINE::OutPort *>
624 std::set<YACS::ENGINE::OutPort *>::iterator iL;
625 $result = PyList_New(0);
628 for (iL=$1.begin(); iL!=$1.end(); iL++)
631 status=PyList_Append($result,ob);
635 PyErr_SetString(PyExc_TypeError,"cannot build the outport list");
641 %typemap(out) std::list<YACS::ENGINE::OutPort *>
643 std::list<YACS::ENGINE::OutPort *>::const_iterator it;
644 $result = PyTuple_New($1.size());
646 for (it = $1.begin(); it != $1.end(); ++it, ++i) {
647 PyTuple_SetItem($result,i,convertPort(*it));
650 %typemap(out) std::list<YACS::ENGINE::InPort *>
652 std::list<YACS::ENGINE::InPort *>::const_iterator it;
653 $result = PyTuple_New($1.size());
655 for (it = $1.begin(); it != $1.end(); ++it, ++i) {
656 PyTuple_SetItem($result,i,convertPort(*it));
659 %typemap(out) std::list<YACS::ENGINE::OutputPort *>
661 std::list<YACS::ENGINE::OutputPort *>::const_iterator it;
662 $result = PyTuple_New($1.size());
664 for (it = $1.begin(); it != $1.end(); ++it, ++i) {
665 PyTuple_SetItem($result,i,convertPort(*it));
668 %typemap(out) std::list<YACS::ENGINE::InputPort *>
670 std::list<YACS::ENGINE::InputPort *>::const_iterator it;
671 $result = PyTuple_New($1.size());
673 for (it = $1.begin(); it != $1.end(); ++it, ++i) {
674 PyTuple_SetItem($result,i,convertPort(*it));
677 %typemap(out) std::list<YACS::ENGINE::InPropertyPort*>
679 std::list<YACS::ENGINE::InPropertyPort *>::const_iterator it;
680 $result = PyTuple_New($1.size());
682 for (it = $1.begin(); it != $1.end(); ++it, ++i) {
683 PyTuple_SetItem($result,i,convertPort(*it));
687 %typemap(out) std::vector< std::list<YACS::ENGINE::Node *> >
689 std::vector< std::list<YACS::ENGINE::Node *> >::const_iterator it;
690 $result = PyList_New($1.size());
692 for (it = $1.begin(); it != $1.end(); ++it, ++i)
694 const std::list<YACS::ENGINE::Node *>& elt(*it);
695 PyObject *tmp(PyList_New(elt.size()));
697 for (auto it2=elt.begin() ; it2!= elt.end() ; ++it2, ++j)
698 PyList_SetItem(tmp,j,convertNode(*it2));
699 PyList_SetItem($result,i,tmp);
705 // ----------------------------------------------------------------------------
710 // a general exception handler
716 catch(YACS::Exception& _e)
718 PyErr_SetString(PyExc_ValueError,_e.what());
721 catch(std::invalid_argument& _e)
723 PyErr_SetString(PyExc_IOError ,_e.what());
725 } catch (std::domain_error& e) {
726 SWIG_exception(SWIG_ValueError, e.what() );
727 } catch (std::overflow_error& e) {
728 SWIG_exception(SWIG_OverflowError, e.what() );
729 } catch (std::out_of_range& e) {
730 PyErr_SetString(PyExc_KeyError,e.what());
732 } catch (std::length_error& e) {
733 SWIG_exception(SWIG_IndexError, e.what() );
734 } catch (std::runtime_error& e) {
735 SWIG_exception(SWIG_RuntimeError, e.what() );
737 OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
738 catch (std::exception& e) {
739 SWIG_exception(SWIG_SystemError, e.what() );
743 SWIG_exception(SWIG_UnknownError, "Unknown exception");
747 // a specific exception handler = generic + release lock
748 %define PYEXCEPTION(name)
752 InterpreterUnlocker _l;
755 catch(YACS::Exception& _e)
757 PyErr_SetString(PyExc_ValueError,_e.what());
760 catch(std::invalid_argument& _e)
762 PyErr_SetString(PyExc_IOError ,_e.what());
764 } catch (std::domain_error& e) {
765 SWIG_exception(SWIG_ValueError, e.what() );
766 } catch (std::overflow_error& e) {
767 SWIG_exception(SWIG_OverflowError, e.what() );
768 } catch (std::out_of_range& e) {
769 PyErr_SetString(PyExc_KeyError,e.what());
771 } catch (std::length_error& e) {
772 SWIG_exception(SWIG_IndexError, e.what() );
773 } catch (std::runtime_error& e) {
774 SWIG_exception(SWIG_RuntimeError, e.what() );
776 OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
777 catch (std::exception& e) {
778 SWIG_exception(SWIG_SystemError, e.what() );
782 SWIG_exception(SWIG_UnknownError, "Unknown exception");
787 %define EXCEPTION(name)
793 catch(YACS::Exception& _e)
795 PyErr_SetString(PyExc_ValueError,_e.what());
798 catch(std::invalid_argument& _e)
800 PyErr_SetString(PyExc_IOError ,_e.what());
802 } catch (std::domain_error& e) {
803 SWIG_exception(SWIG_ValueError, e.what() );
804 } catch (std::overflow_error& e) {
805 SWIG_exception(SWIG_OverflowError, e.what() );
806 } catch (std::out_of_range& e) {
807 PyErr_SetString(PyExc_KeyError,e.what());
809 } catch (std::length_error& e) {
810 SWIG_exception(SWIG_IndexError, e.what() );
811 } catch (std::runtime_error& e) {
812 SWIG_exception(SWIG_RuntimeError, e.what() );
814 OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
815 catch (std::exception& e) {
816 SWIG_exception(SWIG_SystemError, e.what() );
820 SWIG_exception(SWIG_UnknownError, "Unknown exception");
825 * End of Exception section
828 // ----------------------------------------------------------------------------
833 //Release ownership : transfer it to C++
834 %apply SWIGTYPE *DISOWN { YACS::ENGINE::CatalogLoader* factory};
835 %apply SWIGTYPE *DISOWN { YACS::ENGINE::Node *DISOWNnode };
836 %apply SWIGTYPE *DISOWN { Node *DISOWNnode };
838 * End of ownership section
842 * Reference counting section
843 * reference counted objects are created with a count of 1 so we do not incrRef them on wrapping creation
844 * we only decrRef them on wrapping destruction.
845 * Do not forget to declare them new (%newobject) when they are not returned from a constructor
846 * unless they will not be decrRef on wrapping destruction
848 %feature("ref") YACS::ENGINE::RefCounter ""
849 %feature("unref") YACS::ENGINE::RefCounter "$this->decrRef();"
851 // Unfortunately, class ComponentInstance inherits from RefCounter AND PropertyInterface. Thus the ref and
852 // unref features are ambiguous and with swig 2.0.7 at least, we must re-specify those features for class
853 // ComponentInstance unless the instances are destroyed when the Swig object is unref'ed.
854 %feature("ref") YACS::ENGINE::ComponentInstance ""
855 %feature("unref") YACS::ENGINE::ComponentInstance "$this->decrRef();"
857 * End of Reference counting section
860 // ----------------------------------------------------------------------------
865 template <> struct traits_from<YACS::ENGINE::InPort *> {
866 static PyObject *from(YACS::ENGINE::InPort* val){
867 return convertPort(val);
870 template <> struct traits_from<YACS::ENGINE::OutPort *> {
871 static PyObject *from(YACS::ENGINE::OutPort* val) {
872 return convertPort(val);
875 template <> struct traits_from<YACS::ENGINE::InputPort *> {
876 static PyObject *from(YACS::ENGINE::InPort* val){
877 return convertPort(val);
880 template <> struct traits_from<YACS::ENGINE::OutputPort *> {
881 static PyObject *from(YACS::ENGINE::OutPort* val) {
882 return convertPort(val);
889 // ----------------------------------------------------------------------------
891 %include "IteratorPy3.hxx"
892 %include "exception.i"
894 %define REFCOUNT_TEMPLATE(tname, T)
896 This macro is a special wrapping for map with value type which derives from RefCounter.
897 To overload standard SWIG wrapping we define a full specialization of std::map
898 with %extend for 5 basic methods : getitem, setitem, delitem, keys and iter.
899 We also provide an iterator and %extend with the __next__ method : required in python 3.
900 (see https://docs.python.org/3/library/stdtypes.html#iterator-types)
901 Then we complete the interface by deriving the shadow wrapper from
902 the python mixin class (UserDict.DictMixin / collections.MutableMapping with Python 3).
903 Do not forget to declare the new shadow class to SWIG with tname_swigregister(tname).
904 Objects returned by __getitem__ are declared new (%newobject) so that when destroyed they
905 call decrRef (see feature("unref") for RefCounter).
908 %exception IteratorPy3<T>::__next__
912 $action // calls %extend function next() below
914 catch (StopIteratorPy3<T>)
916 PyErr_SetString(PyExc_StopIteration, "End of iterator");
921 %extend IteratorPy3<T>
923 // std::pair<const std::string,T*>& __next__()
924 std::string __next__()
926 if ($self->cur != $self->end)
928 // dereference the iterator and return reference to the object,
929 // after that it increments the iterator
930 //return *self->cur++;
931 std::string key= self->cur->first;
935 throw StopIteratorPy3<T>();
940 class std::map<std::string,T*>
945 void __setitem__(const std::string& name, T* c)
947 std::map<std::string, T* >::iterator i = self->find(name);
948 if (i != self->end())
952 i->second->decrRef();
957 T* __getitem__(std::string name)
959 std::map<std::string, T* >::iterator i = self->find(name);
960 if (i != self->end())
962 i->second->incrRef();
966 throw std::out_of_range("key not found");
968 void __delitem__(std::string name)
970 std::map<std::string, T* >::iterator i = self->find(name);
971 if (i != self->end())
973 i->second->decrRef();
977 throw std::out_of_range("key not found");
981 int pysize = self->size();
982 PyObject* keyList = PyList_New(pysize);
983 std::map<std::string, T* >::const_iterator i = self->begin();
984 for (int j = 0; j < pysize; ++i, ++j)
986 PyList_SET_ITEM(keyList, j, PyUnicode_FromString(i->first.c_str()));
990 IteratorPy3<T> __iter__()
992 // return a constructed IteratorPy3 object
993 return IteratorPy3<T>($self->begin(), $self->end());
997 int pysize = self->size();
1002 %newobject std::map<std::string,T* >::__getitem__;
1003 %newobject std::map<std::string,T* >::__iter__;
1004 %template(tname##it) IteratorPy3<T >;
1005 %template() std::pair<std::string, T* >;
1006 %template(tname) std::map<std::string, T* >;
1009 from collections import MutableMapping
1010 class tname(tname,MutableMapping):pass
1011 tname##_swigregister(tname)