X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FLifeCycleCORBA_SWIG%2FlibSALOME_LifeCycleCORBA.i;h=d2d5fe26866fac3e40e762b5bf3724032d206e1f;hb=77c0da0e72e4af226122e506c00dfca9971a34d3;hp=215d55985d9a03483c720fc202ec963588372d68;hpb=35960e77d7f9f2a5cac7d6550c23f12943bc4378;p=modules%2Fkernel.git diff --git a/src/LifeCycleCORBA_SWIG/libSALOME_LifeCycleCORBA.i b/src/LifeCycleCORBA_SWIG/libSALOME_LifeCycleCORBA.i index 215d55985..d2d5fe268 100644 --- a/src/LifeCycleCORBA_SWIG/libSALOME_LifeCycleCORBA.i +++ b/src/LifeCycleCORBA_SWIG/libSALOME_LifeCycleCORBA.i @@ -1,72 +1,167 @@ -// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. +// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE // -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS // -// See http://www.salome-platform.org/ +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License. // +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// +// ---------------------------------------------------------------------------- +// +%module libSALOME_LifeCycleCORBA +%feature("autodoc", "1"); + +%include -%module libSALOME_LifeCycleCORBA + +// ---------------------------------------------------------------------------- %{ #include "utilities.h" #include "SALOME_LifeCycleCORBA.hxx" +#include "SALOME_FileTransferCORBA.hxx" +#include "SALOME_NamingService.hxx" +#include "ServiceUnreachable.hxx" +#include "Utils_SALOME_Exception.hxx" +#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +typedef int Py_ssize_t; +#define PY_SSIZE_T_MAX INT_MAX +#define PY_SSIZE_T_MIN INT_MIN +#endif using namespace std; + +//--- from omniORBpy.h (not present on Debian Sarge packages) + +struct omniORBpyAPI { + + PyObject* (*cxxObjRefToPyObjRef)(const CORBA::Object_ptr cxx_obj, + CORBA::Boolean hold_lock); + // Convert a C++ object reference to a Python object reference. + // If is true, caller holds the Python interpreter lock. + + CORBA::Object_ptr (*pyObjRefToCxxObjRef)(PyObject* py_obj, + CORBA::Boolean hold_lock); + // Convert a Python object reference to a C++ object reference. + // Raises BAD_PARAM if the Python object is not an object reference. + // If is true, caller holds the Python interpreter lock. + + + omniORBpyAPI(); + // Constructor for the singleton. Sets up the function pointers. +}; + + omniORBpyAPI* api; + %} -%typemap(python,out) Engines::Container_ptr, Engines::Component_ptr + +// ---------------------------------------------------------------------------- + + +%init +%{ + // init section + + PyObject* omnipy = PyImport_ImportModule((char*)"_omnipy"); + if (!omnipy) + { + PyErr_SetString(PyExc_ImportError, + (char*)"Cannot import _omnipy"); + return; + } + PyObject* pyapi = PyObject_GetAttrString(omnipy, (char*)"API"); + api = (omniORBpyAPI*)PyCObject_AsVoidPtr(pyapi); + Py_DECREF(pyapi); +%} + + + +// ---------------------------------------------------------------------------- + +%typemap(python,out) Engines::Container_ptr, Engines::Component_ptr, Engines::fileRef_ptr { MESSAGE("typemap out on CORBA object ptr"); SCRUTE($1); - - // --- Get the Python orb - - PyObject* pdict = PyDict_New(); - PyDict_SetItemString(pdict, "__builtins__", PyEval_GetBuiltins()); - PyRun_String("import CORBA", Py_single_input, pdict, pdict); - PyRun_String("o = CORBA.ORB_init([''], CORBA.ORB_ID);", Py_single_input, - pdict, pdict); - PyObject* orb = PyDict_GetItemString(pdict, "o"); - - // --- Get the C++ orb - - int argc = 0; - char *xargv = ""; - char **argv = &xargv; - CORBA::ORB_var ORB = CORBA::ORB_init(argc, argv); - string s = ORB->object_to_string($1); - SCRUTE(s); - PyObject * tmp = PyString_FromString(s.c_str()); - SCRUTE(tmp); - $result = PyObject_CallMethod(orb, "string_to_object", "O", tmp); + $result = api->cxxObjRefToPyObjRef($1, 1); SCRUTE($result); } +%typemap(python,in) Engines::fileRef_ptr aFileRef +{ + MESSAGE("typemap in on CORBA object ptr"); + try { + CORBA::Object_ptr obj = api->pyObjRefToCxxObjRef($input,1); + $1 = Engines::fileRef::_narrow(obj); + SCRUTE($1); + } + catch (...) { + PyErr_SetString(PyExc_RuntimeError, "not a valid CORBA object ptr"); + } +} -%typemap(typecheck) const Engines::MachineParameters & + +%typemap(python,out) std::string, + string { - $1 = ($input != 0); + MESSAGE("typemap out on std::string"); + SCRUTE($1); + $result = PyString_FromString($1.c_str()); } +%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) Engines::MachineParameters const & +{ + $1 = PyDict_Check($input)? 1 : 0; +} +%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) const Engines::MachineParameters & +{ + $1 = PyDict_Check($input)? 1 : 0; +} + +%typemap(typecheck) std::string, + string +{ + $1 = PyString_Check($input); +} + +%typemap(python,in) std::string, + string +{ + MESSAGE("typemap in on std::string"); + std::string str; + if (PyString_Check($input) == 1) + { + char* value = PyString_AsString($input); + str = value; + $1 = str; + } + else + { + MESSAGE("Not a string"); + PyErr_SetString(PyExc_TypeError,"Must Be a Python string"); + return NULL; + } +} + + %typemap(python,in) const Engines::MachineParameters & { - printf("typemap in on Engines::MachineParameters\n"); - //MESSAGE("typemap in on Engines::MachineParameters"); - //ASSERT (PyDict_Check($input)) + //printf("typemap in on Engines::MachineParameters\n"); + MESSAGE("typemap in on Engines::MachineParameters"); if (PyDict_Check($input) == 1) { Engines::MachineParameters *param = new Engines::MachineParameters ; @@ -78,8 +173,10 @@ param->nb_proc_per_node = 0; param->nb_node = 0; param->isMPI = false; + param->parallelLib = CORBA::string_dup(""); + param->nb_component_nodes = 0; PyObject *key, *value; - int pos = 0; + Py_ssize_t pos = 0; while (PyDict_Next($input, &pos, &key, &value)) { char* keystr = PyString_AsString(key); @@ -116,20 +213,65 @@ { param->isMPI = PyLong_AsLong(value); } + else if (strcmp(keystr,"parallelLib")==0) + { + param->parallelLib = CORBA::string_dup(PyString_AsString(value)); + } + else if (strcmp(keystr,"nb_component_nodes")==0) + { + param->nb_component_nodes = PyLong_AsLong(value); + } } $1 = param; } else { - printf("pas un dico\n"); + MESSAGE("Not a dictionnary"); + PyErr_SetString(PyExc_TypeError,"Must Be a Python Dictionnary"); return NULL; } } + %typemap(python,freearg) const Engines::MachineParameters & { MESSAGE("delete $1"); delete $1; } -%include "SALOME_LifeCycleCORBA.hxx" +// ---------------------------------------------------------------------------- + +%include + +%exception { + Py_BEGIN_ALLOW_THREADS + try { + $action + } + catch (ServiceUnreachable) { + Py_BLOCK_THREADS + PyErr_SetString(PyExc_RuntimeError,"Naming Service Unreacheable"); + return NULL; + } + catch (SALOME_Exception &e) { + Py_BLOCK_THREADS + PyErr_SetString(PyExc_RuntimeError,e.what()); + return NULL; + } + catch (SALOME::SALOME_Exception &e) { + Py_BLOCK_THREADS + PyErr_SetString(PyExc_RuntimeError,e.details.text); + return NULL; + } + catch (...) { + Py_BLOCK_THREADS + PyErr_SetString(PyExc_RuntimeError, "unknown exception"); + return NULL; + } + Py_END_ALLOW_THREADS +} + + +%include +%include +