src/runtime/PythonPorts.hxx

   1 // Copyright (C) 2006-2015  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 _PYTHONPORTS_HXX_
  21 #define _PYTHONPORTS_HXX_
  22
  23 #include <Python.h>
  24
  25 #include "YACSRuntimeSALOMEExport.hxx"
  26 #include "InputPort.hxx"
  27 #include "OutputPort.hxx"
  28
  29 namespace YACS
  30 {
  31   namespace ENGINE
  32   {
  33     class InterpreterUnlocker
  34     {
  35     public:
  36       InterpreterUnlocker() {
  37           gstate_ = PyGILState_Ensure();
  38       }
  39       ~InterpreterUnlocker() {
  40           PyGILState_Release(gstate_);
  41       }
  42     private:
  43       PyGILState_STATE gstate_;
  44     };
  45
  46     class InterpreterSaveThread {
  47     public:
  48       inline InterpreterSaveThread() {
  49         tstate_ = PyEval_SaveThread();
  50       }
  51       inline ~InterpreterSaveThread() {
  52         PyEval_RestoreThread(tstate_);
  53       }
  54       inline void lock() {
  55         PyEval_RestoreThread(tstate_);
  56       }
  57       inline void unlock() {
  58         tstate_ = PyEval_SaveThread();
  59       }
  60     private:
  61       PyThreadState* tstate_;
  62     };
  63
  64
  65     typedef PyObject PyObj;
  66
  67 /*! \brief Class for Python Ports
  68  *
  69  * \ingroup Ports
  70  *
  71  * \see PythonNode
  72  */
  73     class YACSRUNTIMESALOME_EXPORT InputPyPort : public InputPort
  74     {
  75     public:
  76       InputPyPort(const std::string& name, Node * node, TypeCode * type);
  77       InputPyPort(const InputPyPort& other, Node *newHelder);
  78       ~InputPyPort();
  79       bool edIsManuallyInitialized() const;
  80       void edRemoveManInit();
  81       virtual void put(const void *data) throw(ConversionException);
  82       void put(PyObject *data) throw(ConversionException);
  83       InputPort *clone(Node *newHelder) const;
  84       //special typedef PyObj used in SWIG to increment ref count on output
  85       virtual PyObj * getPyObj() const;
  86       virtual std::string getAsString();
  87       void *get() const throw(Exception);
  88       virtual std::string getHumanRepr();
  89       virtual bool isEmpty();
  90       virtual void exSaveInit();
  91       virtual void exRestoreInit();
  92       virtual std::string dump();
  93       virtual std::string typeName() {return "YACS__ENGINE__InputPyPort";}
  94       virtual std::string valToStr();
  95       virtual void valFromStr(std::string valstr);
  96
  97     protected:
  98       PyObject* _data;
  99       PyObject* _initData;
 100     };
 101
 102     class YACSRUNTIMESALOME_EXPORT OutputPyPort : public OutputPort
 103     {
 104     public:
 105       OutputPyPort(const std::string& name, Node * node, TypeCode * type);
 106       OutputPyPort(const OutputPyPort& other, Node *newHelder);
 107       ~OutputPyPort();
 108       virtual void put(const void *data) throw(ConversionException);
 109       void put(PyObject *data) throw(ConversionException);
 110       OutputPort *clone(Node *newHelder) const;
 111       virtual PyObject * get() const;
 112       //special typedef PyObj used in SWIG to increment ref count on output
 113       virtual PyObj * getPyObj() const;
 114       virtual std::string getAsString();
 115       virtual std::string dump();
 116       virtual std::string typeName() {return "YACS__ENGINE__OutputPyPort";}
 117       virtual std::string valToStr();
 118       virtual void valFromStr(std::string valstr);
 119     protected:
 120       PyObject* _data;
 121     };
 122
 123
 124
 125   }
 126 }
 127
 128 #endif