src/engine_swig/engtypemaps.i

   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 %include std_except.i
  21 %include std_string.i
  22 %include std_map.i
  23 %include std_list.i
  24 %include std_vector.i
  25 %include std_set.i
  26
  27 // ----------------------------------------------------------------------------
  28
  29 %{
  30 #include "yacsconfig.h"
  31
  32 #ifdef OMNIORB
  33 #include <omniORB4/CORBA.h>
  34
  35 #include <omniORBpy.h>
  36 omniORBpyAPI* api=0;
  37
  38 #define OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS \
  39 catch (const CORBA::SystemException& ex) { \
  40   return api->handleCxxSystemException(ex); \
  41 }
  42 #else
  43 #define OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
  44 #endif
  45
  46 #include "Node.hxx"
  47 #include "InlineNode.hxx"
  48 #include "ComposedNode.hxx"
  49 #include "ServiceNode.hxx"
  50 #include "ServiceInlineNode.hxx"
  51 #include "ServerNode.hxx"
  52 #include "Proc.hxx"
  53 #include "Bloc.hxx"
  54 #include "ForLoop.hxx"
  55 #include "WhileLoop.hxx"
  56 #include "ForEachLoop.hxx"
  57 #include "Switch.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
  66 #include <sstream>
  67
  68 class InterpreterUnlocker
  69 {
  70 public:
  71   InterpreterUnlocker()
  72     {
  73       _save = PyEval_SaveThread(); // allow Python threads to run
  74     }
  75   ~InterpreterUnlocker()
  76     {
  77       PyEval_RestoreThread(_save); // restore the thread state
  78     }
  79 private:
  80   PyThreadState *_save;
  81 };
  82
  83 static PyObject* convertNode(YACS::ENGINE::Node* node,int owner=0)
  84 {
  85   if (!node)
  86     return SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Node,owner);
  87   PyObject * ob;
  88   //should use $descriptor(YACS::ENGINE::Bloc *) and so on but $descriptor is not defined here
  89   // It is better to define a helper function to avoid code bloat
  90   // First try to find a swig type info by its mangled name
  91   std::string swigtypename="_p_"+node->typeName();
  92   swig_type_info *ret = SWIG_MangledTypeQuery(swigtypename.c_str());
  93   if (ret)
  94     ob=SWIG_NewPointerObj((void*)node,ret,owner);
  95   else
  96     {
  97       //typeName not known by swig. Try dynamic_cast on known classes
  98       //You must respect inheritance order in casting : Bloc before ComposedNode and so on
  99       if(dynamic_cast<YACS::ENGINE::Proc *>(node))
 100         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Proc,owner);
 101       else if(dynamic_cast<YACS::ENGINE::Bloc *>(node))
 102         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Bloc,owner);
 103       else if(dynamic_cast<YACS::ENGINE::ForLoop *>(node))
 104         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ForLoop,owner);
 105       else if(dynamic_cast<YACS::ENGINE::WhileLoop *>(node))
 106         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__WhileLoop,owner);
 107       else if(dynamic_cast<YACS::ENGINE::ForEachLoop *>(node))
 108         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ForEachLoop,owner);
 109       else if(dynamic_cast<YACS::ENGINE::Switch *>(node))
 110         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Switch,owner);
 111       else if(dynamic_cast<YACS::ENGINE::ComposedNode *>(node))
 112         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ComposedNode,owner);
 113       else if(dynamic_cast<YACS::ENGINE::InlineFuncNode *>(node))
 114         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__InlineFuncNode,owner);
 115       else if(dynamic_cast<YACS::ENGINE::InlineNode *>(node))
 116         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__InlineNode,owner);
 117       else if(dynamic_cast<YACS::ENGINE::ServiceInlineNode *>(node))
 118         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ServiceInlineNode,owner);
 119       else if(dynamic_cast<YACS::ENGINE::ServiceNode *>(node))
 120         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ServiceNode,owner);
 121       else if(dynamic_cast<YACS::ENGINE::ServerNode *>(node))
 122         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ServerNode,owner);
 123       else if(dynamic_cast<YACS::ENGINE::ElementaryNode *>(node))
 124         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__ElementaryNode,owner);
 125       else
 126         ob=SWIG_NewPointerObj((void*)node,SWIGTYPE_p_YACS__ENGINE__Node,owner);
 127     }
 128   return ob;
 129 }
 130
 131 static PyObject* convertPort(YACS::ENGINE::Port* port,int owner=0)
 132 {
 133   if(!port)
 134     return SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__Port, owner);
 135   PyObject * ob;
 136   std::string swigtypename="_p_"+port->typeName();
 137   swig_type_info *ret = SWIG_MangledTypeQuery(swigtypename.c_str());
 138   if (ret)
 139     {
 140       YACS::ENGINE::InPropertyPort *inpropertyport = dynamic_cast<YACS::ENGINE::InPropertyPort*>(port);
 141       if(inpropertyport)
 142         return SWIG_NewPointerObj((void*)inpropertyport,ret,owner);
 143
 144       YACS::ENGINE::InputPort *inport = dynamic_cast<YACS::ENGINE::InputPort *>(port);
 145       if(inport)
 146         return SWIG_NewPointerObj((void*)inport,ret,owner);
 147
 148       YACS::ENGINE::OutputPort *outport = dynamic_cast<YACS::ENGINE::OutputPort *>(port);
 149       if(outport)
 150         return SWIG_NewPointerObj((void*)outport,ret,owner);
 151
 152       YACS::ENGINE::InputDataStreamPort *indsport = dynamic_cast<YACS::ENGINE::InputDataStreamPort *>(port);
 153       if(indsport)
 154         return SWIG_NewPointerObj((void*)indsport,ret,owner);
 155
 156       YACS::ENGINE::OutputDataStreamPort *outdsport = dynamic_cast<YACS::ENGINE::OutputDataStreamPort *>(port);
 157       if(outdsport)
 158         return SWIG_NewPointerObj((void*)outdsport,ret,owner);
 159
 160       return SWIG_NewPointerObj((void*)port,ret,owner);
 161     }
 162   else
 163     {
 164       if(YACS::ENGINE::AnyInputPort *cport =dynamic_cast<YACS::ENGINE::AnyInputPort *>(port))
 165         ob=SWIG_NewPointerObj((void*)cport,SWIGTYPE_p_YACS__ENGINE__AnyInputPort,owner);
 166       else if(YACS::ENGINE::AnyOutputPort *cport =dynamic_cast<YACS::ENGINE::AnyOutputPort *>(port))
 167         ob=SWIG_NewPointerObj((void*)cport,SWIGTYPE_p_YACS__ENGINE__AnyOutputPort,owner);
 168       else if(dynamic_cast<YACS::ENGINE::InPropertyPort*>(port))
 169         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InPropertyPort,owner);
 170       else if(dynamic_cast<YACS::ENGINE::InputPort *>(port))
 171         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InputPort,owner);
 172       else if(dynamic_cast<YACS::ENGINE::OutputPort *>(port))
 173         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutputPort,owner);
 174       else if(dynamic_cast<YACS::ENGINE::InputDataStreamPort *>(port))
 175         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InputDataStreamPort, owner);
 176       else if(dynamic_cast<YACS::ENGINE::OutputDataStreamPort *>(port))
 177         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutputDataStreamPort, owner);
 178       else if(dynamic_cast<YACS::ENGINE::InPort *>(port))
 179         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InPort, owner);
 180       else if(dynamic_cast<YACS::ENGINE::OutPort *>(port))
 181         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutPort, owner);
 182       else if(dynamic_cast<YACS::ENGINE::InGate *>(port))
 183         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__InGate, owner);
 184       else if(dynamic_cast<YACS::ENGINE::OutGate *>(port))
 185         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__OutGate, owner);
 186       else
 187         ob=SWIG_NewPointerObj((void*)port,SWIGTYPE_p_YACS__ENGINE__Port, owner);
 188     }
 189   return ob;
 190 }
 191
 192 static PyObject *convertContainer(YACS::ENGINE::Container *cont, int owner=0)
 193 {
 194   if(!cont)
 195     return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
 196   if(dynamic_cast<YACS::ENGINE::HomogeneousPoolContainer *>(cont))
 197     {
 198       return SWIG_NewPointerObj((void*)dynamic_cast<YACS::ENGINE::HomogeneousPoolContainer *>(cont),SWIGTYPE_p_YACS__ENGINE__HomogeneousPoolContainer, owner);
 199     }
 200   return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
 201 }
 202
 203 //convertFromPyObjVectorOfObj<YACS::ENGINE::SequenceAny *>(pyLi,SWIGTYPE_p_YACS__ENGINE__SequenceAny,"SequenceAny")
 204 template<class T>
 205 static void convertFromPyObjVectorOfObj(PyObject *pyLi, swig_type_info *ty, const char *typeStr, typename std::vector<T>& ret)
 206 {
 207   void *argp=0;
 208   if(PyList_Check(pyLi))
 209     {
 210       int size=PyList_Size(pyLi);
 211       ret.resize(size);
 212       for(int i=0;i<size;i++)
 213         {
 214           PyObject *obj=PyList_GetItem(pyLi,i);
 215           int status=SWIG_ConvertPtr(obj,&argp,ty,0|0);
 216           if(!SWIG_IsOK(status))
 217             {
 218               std::ostringstream oss; oss << "convertFromPyObjVectorOfObj : list is excepted to contain only " << typeStr << " instances !";
 219               throw YACS::Exception(oss.str());
 220             }
 221           T arg=reinterpret_cast< T >(argp);
 222           ret[i]=arg;
 223         }
 224     }
 225   else if(PyTuple_Check(pyLi))
 226     {
 227       int size=PyTuple_Size(pyLi);
 228       ret.resize(size);
 229       for(int i=0;i<size;i++)
 230         {
 231           PyObject *obj=PyTuple_GetItem(pyLi,i);
 232           int status=SWIG_ConvertPtr(obj,&argp,ty,0|0);
 233           if(!SWIG_IsOK(status))
 234             {
 235               std::ostringstream oss; oss << "convertFromPyObjVectorOfObj : tuple is excepted to contain only " << typeStr << " instances !";
 236               throw YACS::Exception(oss.str());
 237             }
 238           T arg=reinterpret_cast< T >(argp);
 239           ret[i]=arg;
 240         }
 241     }
 242   else if(SWIG_IsOK(SWIG_ConvertPtr(pyLi,&argp,ty,0|0)))
 243     {
 244       ret.resize(1);
 245       T arg=reinterpret_cast< T >(argp);
 246       ret[0]=arg;
 247     }
 248   else
 249     throw YACS::Exception("convertFromPyObjVectorOfObj : not a list nor a tuple");
 250 }
 251
 252 %}
 253
 254 #if SWIG_VERSION >= 0x010329
 255 %template()        std::list<int>;
 256 %template()        std::list<std::string>;
 257 #else
 258
 259 #ifdef SWIGPYTHON
 260 %typemap(out) std::list<int>
 261 {
 262   int i;
 263   std::list<int>::iterator iL;
 264
 265   $result = PyList_New($1.size());
 266   for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
 267     PyList_SetItem($result,i,PyLong_FromLong((*iL)));
 268 }
 269
 270 %typemap(out) std::list<std::string>
 271 {
 272   int i;
 273   std::list<std::string>::iterator iL;
 274
 275   $result = PyList_New($1.size());
 276   for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
 277     PyList_SetItem($result,i,PyString_FromString((*iL).c_str()));
 278 }
 279
 280 %typemap(in) std::list<std::string>
 281 {
 282   /* Check if input is a list */
 283   if (PyList_Check($input))
 284     {
 285       int size = PyList_Size($input);
 286       int i = 0;
 287       std::list<std::string> myList;
 288       $1 = myList;
 289       for (i = 0; i < size; i++)
 290         {
 291           PyObject *o = PyList_GetItem($input,i);
 292           if (PyString_Check(o))
 293             $1.push_back(std::string(PyString_AsString(PyList_GetItem($input,i))));
 294           else
 295             {
 296               PyErr_SetString(PyExc_TypeError,"list must contain strings");
 297               return NULL;
 298             }
 299         }
 300     }
 301   else
 302     {
 303       PyErr_SetString(PyExc_TypeError,"not a list");
 304       return NULL;
 305     }
 306 }
 307 #endif
 308 #endif
 309
 310 #ifdef SWIGPYTHON
 311
 312 %typecheck(SWIG_TYPECHECK_POINTER) YACS::ENGINE::Any*
 313 {
 314   void *ptr;
 315   if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0) == 0)
 316     $1 = 1;
 317   else if (PyInt_Check($input))
 318     $1 = 1;
 319   else if(PyFloat_Check($input))
 320     $1 = 1;
 321   else if (PyString_Check($input))
 322     $1 = 1;
 323   else
 324     $1 = 0;
 325 }
 326
 327 %typemap(in) YACS::ENGINE::Any* (int is_new_object)
 328 {
 329   if ((SWIG_ConvertPtr($input,(void **) &$1, $1_descriptor,SWIG_POINTER_EXCEPTION)) == 0)
 330     {
 331       // It is an Any : it is converted by SWIG_ConvertPtr $input -> $1
 332       is_new_object=0;
 333     }
 334   else if (PyInt_Check($input))
 335     {
 336       // It is an Int
 337       $1=YACS::ENGINE::AtomAny::New((int)PyInt_AsLong($input));
 338       is_new_object=1;
 339     }
 340   else if(PyFloat_Check($input))
 341     {
 342       // It is a Float
 343       $1=YACS::ENGINE::AtomAny::New(PyFloat_AsDouble($input));
 344       is_new_object=1;
 345     }
 346   else if(PyString_Check($input))
 347     {
 348       // It is a Float
 349       $1=YACS::ENGINE::AtomAny::New(PyString_AsString($input));
 350       is_new_object=1;
 351     }
 352   else
 353     {
 354       // It is an error
 355       PyErr_SetString(PyExc_TypeError,"not a yacs any or a convertible type");
 356       return NULL;
 357     }
 358 }
 359
 360 %typemap(directorout) YACS::ENGINE::Any*
 361 {
 362   if ((SWIG_ConvertPtr($1,(void **) &$result, $1_descriptor,SWIG_POINTER_EXCEPTION)) == 0)
 363     {
 364       // It is an Any : it is converted by SWIG_ConvertPtr $input -> $1
 365     }
 366   else if (PyInt_Check($1))
 367     {
 368       // It is an Int
 369       $result=YACS::ENGINE::AtomAny::New((int)PyInt_AsLong($1));
 370     }
 371   else if(PyFloat_Check($1))
 372     {
 373       // It is a Float
 374       $result=YACS::ENGINE::AtomAny::New(PyFloat_AsDouble($1));
 375     }
 376   else if(PyString_Check($1))
 377     {
 378       // It is a String
 379       $result=YACS::ENGINE::AtomAny::New(PyString_AsString($1));
 380     }
 381   else
 382     {
 383       // It is an error
 384       PyErr_SetString(PyExc_TypeError,"not a yacs any or a convertible type");
 385       return NULL;
 386     }
 387 }
 388
 389 %typemap(freearg) YACS::ENGINE::Any *inSample
 390 {
 391   //a reference is taken by the routine called
 392   if (!is_new_object$argnum) $1->incrRef();
 393 }
 394
 395 %typemap(freearg) YACS::ENGINE::Any*
 396 {
 397   //no reference taken by the routine called
 398   if (is_new_object$argnum) $1->decrRef();
 399 }
 400
 401 %typemap(out) YACS::ENGINE::Any*
 402 {
 403   if(dynamic_cast<YACS::ENGINE::SequenceAny *>($1))
 404     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__SequenceAny,$owner);
 405   else if(dynamic_cast<YACS::ENGINE::ArrayAny *>($1))
 406     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__ArrayAny,$owner);
 407   else if(dynamic_cast<YACS::ENGINE::StructAny *>($1))
 408     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__StructAny,$owner);
 409   else
 410     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__Any,$owner);
 411 }
 412
 413 %typemap(out) YACS::ENGINE::TypeCode*
 414 {
 415   if(dynamic_cast<YACS::ENGINE::TypeCodeStruct *>($1))
 416     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCodeStruct,$owner);
 417   else if(dynamic_cast<YACS::ENGINE::TypeCodeSeq *>($1))
 418     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCodeSeq,$owner);
 419   else if(dynamic_cast<YACS::ENGINE::TypeCodeObjref *>($1))
 420     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCodeObjref,$owner);
 421   else
 422     $result=SWIG_NewPointerObj((void*)$1,SWIGTYPE_p_YACS__ENGINE__TypeCode,$owner);
 423 }
 424
 425 %typemap(in) std::list<YACS::ENGINE::TypeCodeObjref*>
 426 {
 427   // Check if input is a list
 428   if (PyList_Check($input))
 429     {
 430       int size = PyList_Size($input);
 431       int i = 0;
 432       std::list<YACS::ENGINE::TypeCodeObjref*> myList;
 433       $1 = myList;
 434       for (i = 0; i < size; i++)
 435         {
 436           PyObject *o = PyList_GetItem($input,i);
 437           YACS::ENGINE::TypeCode* temp;
 438           if ((SWIG_ConvertPtr(o, (void **) &temp, $descriptor(YACS::ENGINE::TypeCode*),0)) == -1)
 439             {
 440               PyErr_SetString(PyExc_TypeError,"not a YACS::ENGINE::TypeCode*");
 441               return NULL;
 442             }
 443           else
 444             {
 445               if(temp->kind() == YACS::ENGINE::Objref)
 446                 $1.push_back((YACS::ENGINE::TypeCodeObjref*)temp);
 447               else
 448                 {
 449                   PyErr_SetString(PyExc_TypeError,"not a YACS::ENGINE::TypeCodeObjref*");
 450                   return NULL;
 451                 }
 452             }
 453         }
 454     }
 455   else
 456     {
 457       PyErr_SetString(PyExc_TypeError,"not a list");
 458       return NULL;
 459     }
 460 }
 461
 462 %typemap(out) YACS::ENGINE::Node*
 463 {
 464   $result=convertNode($1,$owner);
 465 }
 466
 467 %typemap(out) YACS::ENGINE::ServiceNode*
 468 {
 469   $result=convertNode($1,$owner);
 470 }
 471
 472 %typemap(out) YACS::ENGINE::InlineNode*
 473 {
 474   $result=convertNode($1,$owner);
 475 }
 476
 477 %typemap(out) YACS::ENGINE::InlineFuncNode*
 478 {
 479   $result=convertNode($1,$owner);
 480 }
 481
 482 %typemap(out) YACS::ENGINE::ComposedNode*
 483 {
 484   $result=convertNode($1,$owner);
 485 }
 486
 487 %typemap(out) YACS::ENGINE::OptimizerLoop*
 488 {
 489   $result=convertNode($1,$owner);
 490 }
 491
 492 %typemap(out) YACS::ENGINE::Proc*
 493 {
 494   $result=convertNode($1,$owner);
 495 }
 496
 497 %typemap(out) std::set<YACS::ENGINE::Node *>
 498 {
 499   int i;
 500   std::set<YACS::ENGINE::Node *>::iterator iL;
 501
 502   $result = PyList_New($1.size());
 503   PyObject * ob;
 504   for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
 505     {
 506       ob=convertNode(*iL);
 507       PyList_SetItem($result,i,ob);
 508     }
 509 }
 510
 511 %typemap(out) std::list<YACS::ENGINE::Node *>
 512 {
 513   int i;
 514   std::list<YACS::ENGINE::Node *>::iterator iL;
 515
 516   $result = PyList_New($1.size());
 517   PyObject * ob;
 518   for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
 519     {
 520       ob=convertNode(*iL);
 521       PyList_SetItem($result,i,ob);
 522     }
 523 }
 524
 525 %typemap(out) YACS::ENGINE::InputPort*,YACS::ENGINE::OutputPort*,YACS::ENGINE::InPort*,YACS::ENGINE::OutPort*,YACS::ENGINE::InPropertyPort*
 526 {
 527   $result=convertPort($1,$owner);
 528 }
 529
 530 %typemap(out) std::set<YACS::ENGINE::InGate *>
 531 {
 532   int i;
 533   std::set<YACS::ENGINE::InGate *>::iterator iL;
 534   $result = PyList_New($1.size());
 535   PyObject * ob;
 536   for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
 537     {
 538       ob=convertPort(*iL);
 539       PyList_SetItem($result,i,ob);
 540     }
 541 }
 542
 543 %typemap(out) std::set<YACS::ENGINE::OutGate *>
 544 {
 545   int i;
 546   std::set<YACS::ENGINE::OutGate *>::iterator iL;
 547   $result = PyList_New($1.size());
 548   PyObject * ob;
 549   for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
 550     {
 551       ob=convertPort(*iL);
 552       PyList_SetItem($result,i,ob);
 553     }
 554 }
 555
 556 %typemap(out) std::set<YACS::ENGINE::InPort *>
 557 {
 558   std::set<YACS::ENGINE::InPort *>::iterator iL;
 559   $result = PyList_New(0);
 560   PyObject * ob;
 561   int status;
 562   for (iL=$1.begin(); iL!=$1.end(); iL++)
 563     {
 564       ob=convertPort(*iL);
 565       status=PyList_Append($result,ob);
 566       Py_DECREF(ob);
 567       if (status < 0)
 568         {
 569           PyErr_SetString(PyExc_TypeError,"cannot build the inport list");
 570           return NULL;
 571         }
 572     }
 573 }
 574
 575 %typemap(out) std::set<YACS::ENGINE::OutPort *>
 576 {
 577   std::set<YACS::ENGINE::OutPort *>::iterator iL;
 578   $result = PyList_New(0);
 579   PyObject * ob;
 580   int status;
 581   for (iL=$1.begin(); iL!=$1.end(); iL++)
 582     {
 583       ob=convertPort(*iL);
 584       status=PyList_Append($result,ob);
 585       Py_DECREF(ob);
 586       if (status < 0)
 587         {
 588           PyErr_SetString(PyExc_TypeError,"cannot build the outport list");
 589           return NULL;
 590         }
 591     }
 592 }
 593
 594 %typemap(out) std::list<YACS::ENGINE::OutPort *>
 595 {
 596   std::list<YACS::ENGINE::OutPort *>::const_iterator it;
 597   $result = PyTuple_New($1.size());
 598   int i = 0;
 599   for (it = $1.begin(); it != $1.end(); ++it, ++i) {
 600     PyTuple_SetItem($result,i,convertPort(*it));
 601   }
 602 }
 603 %typemap(out) std::list<YACS::ENGINE::InPort *>
 604 {
 605   std::list<YACS::ENGINE::InPort *>::const_iterator it;
 606   $result = PyTuple_New($1.size());
 607   int i = 0;
 608   for (it = $1.begin(); it != $1.end(); ++it, ++i) {
 609     PyTuple_SetItem($result,i,convertPort(*it));
 610   }
 611 }
 612 %typemap(out) std::list<YACS::ENGINE::OutputPort *>
 613 {
 614   std::list<YACS::ENGINE::OutputPort *>::const_iterator it;
 615   $result = PyTuple_New($1.size());
 616   int i = 0;
 617   for (it = $1.begin(); it != $1.end(); ++it, ++i) {
 618     PyTuple_SetItem($result,i,convertPort(*it));
 619   }
 620 }
 621 %typemap(out) std::list<YACS::ENGINE::InputPort *>
 622 {
 623   std::list<YACS::ENGINE::InputPort *>::const_iterator it;
 624   $result = PyTuple_New($1.size());
 625   int i = 0;
 626   for (it = $1.begin(); it != $1.end(); ++it, ++i) {
 627     PyTuple_SetItem($result,i,convertPort(*it));
 628   }
 629 }
 630 %typemap(out) std::list<YACS::ENGINE::InPropertyPort*>
 631 {
 632   std::list<YACS::ENGINE::InPropertyPort *>::const_iterator it;
 633   $result = PyTuple_New($1.size());
 634   int i = 0;
 635   for (it = $1.begin(); it != $1.end(); ++it, ++i) {
 636     PyTuple_SetItem($result,i,convertPort(*it));
 637   }
 638 }
 639
 640 #endif
 641
 642 /*
 643  * Exception section
 644  */
 645 // a general exception handler
 646 %exception {
 647    try
 648    {
 649       $action
 650    }
 651    catch(YACS::Exception& _e)
 652    {
 653       PyErr_SetString(PyExc_ValueError,_e.what());
 654       return NULL;
 655    }
 656    catch(std::invalid_argument& _e)
 657    {
 658       PyErr_SetString(PyExc_IOError ,_e.what());
 659       return NULL;
 660    } catch (std::domain_error& e) {
 661       SWIG_exception(SWIG_ValueError, e.what() );
 662    } catch (std::overflow_error& e) {
 663       SWIG_exception(SWIG_OverflowError, e.what() );
 664    } catch (std::out_of_range& e) {
 665       PyErr_SetString(PyExc_KeyError,e.what());
 666       return NULL;
 667    } catch (std::length_error& e) {
 668       SWIG_exception(SWIG_IndexError, e.what() );
 669    } catch (std::runtime_error& e) {
 670       SWIG_exception(SWIG_RuntimeError, e.what() );
 671    }
 672    OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
 673    catch (std::exception& e) {
 674       SWIG_exception(SWIG_SystemError, e.what() );
 675    }
 676    catch(...)
 677    {
 678      SWIG_exception(SWIG_UnknownError, "Unknown exception");
 679    }
 680 }
 681
 682 // a specific exception handler = generic + release lock
 683 %define PYEXCEPTION(name)
 684 %exception name {
 685    try
 686    {
 687       InterpreterUnlocker _l;
 688       $action
 689    }
 690    catch(YACS::Exception& _e)
 691    {
 692       PyErr_SetString(PyExc_ValueError,_e.what());
 693       return NULL;
 694    }
 695    catch(std::invalid_argument& _e)
 696    {
 697       PyErr_SetString(PyExc_IOError ,_e.what());
 698       return NULL;
 699    } catch (std::domain_error& e) {
 700       SWIG_exception(SWIG_ValueError, e.what() );
 701    } catch (std::overflow_error& e) {
 702       SWIG_exception(SWIG_OverflowError, e.what() );
 703    } catch (std::out_of_range& e) {
 704       PyErr_SetString(PyExc_KeyError,e.what());
 705       return NULL;
 706    } catch (std::length_error& e) {
 707       SWIG_exception(SWIG_IndexError, e.what() );
 708    } catch (std::runtime_error& e) {
 709       SWIG_exception(SWIG_RuntimeError, e.what() );
 710    }
 711    OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
 712    catch (std::exception& e) {
 713       SWIG_exception(SWIG_SystemError, e.what() );
 714    }
 715    catch(...)
 716    {
 717      SWIG_exception(SWIG_UnknownError, "Unknown exception");
 718    }
 719 }
 720 %enddef
 721
 722 %define EXCEPTION(name)
 723 %exception name {
 724    try
 725    {
 726       $action
 727    }
 728    catch(YACS::Exception& _e)
 729    {
 730       PyErr_SetString(PyExc_ValueError,_e.what());
 731       return NULL;
 732    }
 733    catch(std::invalid_argument& _e)
 734    {
 735       PyErr_SetString(PyExc_IOError ,_e.what());
 736       return NULL;
 737    } catch (std::domain_error& e) {
 738       SWIG_exception(SWIG_ValueError, e.what() );
 739    } catch (std::overflow_error& e) {
 740       SWIG_exception(SWIG_OverflowError, e.what() );
 741    } catch (std::out_of_range& e) {
 742       PyErr_SetString(PyExc_KeyError,e.what());
 743       return NULL;
 744    } catch (std::length_error& e) {
 745       SWIG_exception(SWIG_IndexError, e.what() );
 746    } catch (std::runtime_error& e) {
 747       SWIG_exception(SWIG_RuntimeError, e.what() );
 748    }
 749    OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS
 750    catch (std::exception& e) {
 751       SWIG_exception(SWIG_SystemError, e.what() );
 752    }
 753    catch(...)
 754    {
 755      SWIG_exception(SWIG_UnknownError, "Unknown exception");
 756    }
 757 }
 758 %enddef
 759 /*
 760  * End of Exception section
 761  */
 762
 763 /*
 764  * Ownership section
 765  */
 766 //Release ownership : transfer it to C++
 767 %apply SWIGTYPE *DISOWN { YACS::ENGINE::CatalogLoader* factory};
 768 %apply SWIGTYPE *DISOWN { YACS::ENGINE::Node *DISOWNnode };
 769 %apply SWIGTYPE *DISOWN { Node *DISOWNnode };
 770 /*
 771  * End of ownership section
 772  */
 773
 774 /*
 775  * Reference counting section
 776  * reference counted objects are created with a count of 1 so we do not incrRef them on wrapping creation
 777  * we only decrRef them on wrapping destruction.
 778  * Do not forget to declare them new (%newobject) when they are not returned from a constructor
 779  * unless they will not be decrRef on wrapping destruction
 780  */
 781 %feature("ref")   YACS::ENGINE::RefCounter  ""
 782 %feature("unref") YACS::ENGINE::RefCounter  "$this->decrRef();"
 783
 784 // Unfortunately, class ComponentInstance inherits from RefCounter AND PropertyInterface. Thus the ref and
 785 // unref features are ambiguous and with swig 2.0.7 at least, we must re-specify those features for class
 786 // ComponentInstance unless the instances are destroyed when the Swig object is unref'ed.
 787 %feature("ref")   YACS::ENGINE::ComponentInstance  ""
 788 %feature("unref") YACS::ENGINE::ComponentInstance  "$this->decrRef();"
 789 /*
 790  * End of Reference counting section
 791  */
 792
 793 /*
 794 %wrapper %{
 795   namespace swig {
 796     template <> struct traits_from<YACS::ENGINE::InPort *> {
 797       static PyObject *from(YACS::ENGINE::InPort* val){
 798         return convertPort(val);
 799       }
 800     };
 801     template <> struct traits_from<YACS::ENGINE::OutPort *> {
 802       static PyObject *from(YACS::ENGINE::OutPort* val) {
 803         return convertPort(val);
 804       }
 805     };
 806     template <> struct traits_from<YACS::ENGINE::InputPort *> {
 807       static PyObject *from(YACS::ENGINE::InPort* val){
 808         return convertPort(val);
 809       }
 810     };
 811     template <> struct traits_from<YACS::ENGINE::OutputPort *> {
 812       static PyObject *from(YACS::ENGINE::OutPort* val) {
 813         return convertPort(val);
 814       }
 815     };
 816   }
 817 %}
 818 */
 819
 820 %define REFCOUNT_TEMPLATE(tname, T...)
 821 /*
 822  This macro is a special wrapping for map with value type which derives from RefCounter.
 823  To overload standard SWIG wrapping we define a full specialization of std::map
 824  with %extend for 4 basic methods : getitem, setitem, delitem and keys.
 825  Then we complete the interface by deriving the shadow wrapper from
 826  the python mixin class (UserDict.DictMixin / collections.MutableMapping with Python 3).
 827  Do not forget to declare the new shadow class to SWIG with tname_swigregister(tname).
 828  Objects returned by __getitem__ are declared new (%newobject) so that when destroyed they
 829  call decrRef (see feature("unref") for RefCounter).
 830 */
 831 template<>
 832 class std::map<std::string,T*>
 833 {
 834 public:
 835 %extend
 836 {
 837   void __setitem__(const std::string& name, T* c)
 838     {
 839       std::map<std::string, T* >::iterator i = self->find(name);
 840       if (i != self->end())
 841         {
 842           if(c==i->second)
 843             return;
 844           i->second->decrRef();
 845         }
 846       (*self)[name]=c;
 847       c->incrRef();
 848     }
 849   T* __getitem__(std::string name)
 850     {
 851       std::map<std::string, T* >::iterator i = self->find(name);
 852       if (i != self->end())
 853         {
 854           i->second->incrRef();
 855           return i->second;
 856         }
 857       else
 858         throw std::out_of_range("key not found");
 859     }
 860   void __delitem__(std::string name)
 861     {
 862       std::map<std::string, T* >::iterator i = self->find(name);
 863       if (i != self->end()){
 864         i->second->decrRef();
 865         self->erase(i);
 866       }
 867       else
 868         throw std::out_of_range("key not found");
 869     }
 870   PyObject* keys() {
 871       int pysize = self->size();
 872       PyObject* keyList = PyList_New(pysize);
 873       std::map<std::string, T* >::const_iterator i = self->begin();
 874       for (int j = 0; j < pysize; ++i, ++j) {
 875         PyList_SET_ITEM(keyList, j, PyString_FromString(i->first.c_str()));
 876       }
 877       return keyList;
 878     }
 879 }
 880 };
 881
 882 %newobject std::map<std::string,T* >::__getitem__;
 883 %template()   std::pair<std::string, T* >;
 884 %template(tname)    std::map<std::string, T* >;
 885 %pythoncode{
 886 from collections import MutableMapping
 887 class tname(tname,MutableMapping):pass
 888 tname##_swigregister(tname)
 889 }
 890 %enddef
 891
 892