-// Copyright (C) 2006-2014 CEA/DEN, EDF R&D
+// Copyright (C) 2006-2016 CEA/DEN, EDF R&D
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
#ifdef OMNIORB
#include <omniORB4/CORBA.h>
-//--- 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 <hold_lock> 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 <hold_lock> is true, caller holds the Python interpreter lock.
-
- PyObject* (*handleCxxSystemException)(const CORBA::SystemException& ex);
- // Sets the Python exception state to reflect the given C++ system
- // exception. Always returns NULL. The caller must hold the Python
- // interpreter lock.
-};
-
-omniORBPYAPI* api;
+#include <omniORBpy.h>
+omniORBpyAPI* api=0;
#define OMNIPY_CATCH_AND_HANDLE_SYSTEM_EXCEPTIONS \
catch (const CORBA::SystemException& ex) { \
#include "InputDataStreamPort.hxx"
#include "OutputDataStreamPort.hxx"
#include "OptimizerLoop.hxx"
+#include "HomogeneousPoolContainer.hxx"
+
+#include <sstream>
class InterpreterUnlocker
{
return ob;
}
+static PyObject *convertContainer(YACS::ENGINE::Container *cont, int owner=0)
+{
+ if(!cont)
+ return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
+ if(dynamic_cast<YACS::ENGINE::HomogeneousPoolContainer *>(cont))
+ {
+ return SWIG_NewPointerObj((void*)dynamic_cast<YACS::ENGINE::HomogeneousPoolContainer *>(cont),SWIGTYPE_p_YACS__ENGINE__HomogeneousPoolContainer, owner);
+ }
+ return SWIG_NewPointerObj((void*)cont,SWIGTYPE_p_YACS__ENGINE__Container, owner);
+}
+
+//convertFromPyObjVectorOfObj<YACS::ENGINE::SequenceAny *>(pyLi,SWIGTYPE_p_YACS__ENGINE__SequenceAny,"SequenceAny")
+template<class T>
+static void convertFromPyObjVectorOfObj(PyObject *pyLi, swig_type_info *ty, const char *typeStr, typename std::vector<T>& ret)
+{
+ void *argp=0;
+ if(PyList_Check(pyLi))
+ {
+ int size=PyList_Size(pyLi);
+ ret.resize(size);
+ for(int i=0;i<size;i++)
+ {
+ PyObject *obj=PyList_GetItem(pyLi,i);
+ int status=SWIG_ConvertPtr(obj,&argp,ty,0|0);
+ if(!SWIG_IsOK(status))
+ {
+ std::ostringstream oss; oss << "convertFromPyObjVectorOfObj : list is excepted to contain only " << typeStr << " instances !";
+ throw YACS::Exception(oss.str());
+ }
+ T arg=reinterpret_cast< T >(argp);
+ ret[i]=arg;
+ }
+ }
+ else if(PyTuple_Check(pyLi))
+ {
+ int size=PyTuple_Size(pyLi);
+ ret.resize(size);
+ for(int i=0;i<size;i++)
+ {
+ PyObject *obj=PyTuple_GetItem(pyLi,i);
+ int status=SWIG_ConvertPtr(obj,&argp,ty,0|0);
+ if(!SWIG_IsOK(status))
+ {
+ std::ostringstream oss; oss << "convertFromPyObjVectorOfObj : tuple is excepted to contain only " << typeStr << " instances !";
+ throw YACS::Exception(oss.str());
+ }
+ T arg=reinterpret_cast< T >(argp);
+ ret[i]=arg;
+ }
+ }
+ else if(SWIG_IsOK(SWIG_ConvertPtr(pyLi,&argp,ty,0|0)))
+ {
+ ret.resize(1);
+ T arg=reinterpret_cast< T >(argp);
+ ret[0]=arg;
+ }
+ else
+ throw YACS::Exception("convertFromPyObjVectorOfObj : not a list nor a tuple");
+}
+
%}
#if SWIG_VERSION >= 0x010329
$result = PyList_New($1.size());
for (i=0, iL=$1.begin(); iL!=$1.end(); i++, iL++)
- PyList_SetItem($result,i,PyString_FromString((*iL).c_str()));
+ PyList_SetItem($result,i,PyUnicode_FromString((*iL).c_str()));
}
%typemap(in) std::list<std::string>
for (i = 0; i < size; i++)
{
PyObject *o = PyList_GetItem($input,i);
- if (PyString_Check(o))
- $1.push_back(std::string(PyString_AsString(PyList_GetItem($input,i))));
+ if (PyUnicode_Check(o))
+ $1.push_back(std::string(PyUnicode_AsUTF8(PyList_GetItem($input,i))));
else
{
PyErr_SetString(PyExc_TypeError,"list must contain strings");
void *ptr;
if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0) == 0)
$1 = 1;
- else if (PyInt_Check($input))
+ else if (PyLong_Check($input))
$1 = 1;
else if(PyFloat_Check($input))
$1 = 1;
- else if (PyString_Check($input))
+ else if (PyUnicode_Check($input))
+ $1 = 1;
+ else if (PyBytes_Check($input))
$1 = 1;
else
$1 = 0;
// It is an Any : it is converted by SWIG_ConvertPtr $input -> $1
is_new_object=0;
}
- else if (PyInt_Check($input))
+ else if (PyLong_Check($input))
{
// It is an Int
- $1=YACS::ENGINE::AtomAny::New((int)PyInt_AsLong($input));
+ $1=YACS::ENGINE::AtomAny::New((int)PyLong_AsLong($input));
is_new_object=1;
}
else if(PyFloat_Check($input))
$1=YACS::ENGINE::AtomAny::New(PyFloat_AsDouble($input));
is_new_object=1;
}
- else if(PyString_Check($input))
+ else if(PyUnicode_Check($input))
{
- // It is a Float
- $1=YACS::ENGINE::AtomAny::New(PyString_AsString($input));
+ // It is a Unicode
+ $1=YACS::ENGINE::AtomAny::New(PyUnicode_AsUTF8($input));
+ is_new_object=1;
+ }
+ else if(PyBytes_Check($input))
+ {
+ // It is a Bytes
+ $1=YACS::ENGINE::AtomAny::New(PyBytes_AsString($input));
is_new_object=1;
}
else
else if (PyInt_Check($1))
{
// It is an Int
- $result=YACS::ENGINE::AtomAny::New((int)PyInt_AsLong($1));
+ $result=YACS::ENGINE::AtomAny::New((int)PyLong_AsLong($1));
}
else if(PyFloat_Check($1))
{
// It is a Float
$result=YACS::ENGINE::AtomAny::New(PyFloat_AsDouble($1));
}
- else if(PyString_Check($1))
+ else if(PyUnicode_Check($1))
+ {
+ // It is a Unicode
+ $result=YACS::ENGINE::AtomAny::New(PyUnicode_AsUTF8($1));
+ }
+ else if(PyBytes_Check($1))
{
- // It is a String
- $result=YACS::ENGINE::AtomAny::New(PyString_AsString($1));
+ // It is a Bytes
+ $result=YACS::ENGINE::AtomAny::New(PyBytes_AsString($1));
}
else
{
To overload standard SWIG wrapping we define a full specialization of std::map
with %extend for 4 basic methods : getitem, setitem, delitem and keys.
Then we complete the interface by deriving the shadow wrapper from
- the python mixin class (UserDict.DictMixin).
+ the python mixin class (UserDict.DictMixin / collections.MutableMapping with Python 3).
Do not forget to declare the new shadow class to SWIG with tname_swigregister(tname).
Objects returned by __getitem__ are declared new (%newobject) so that when destroyed they
call decrRef (see feature("unref") for RefCounter).
*/
+/*
+%inline %{
+template <typename U> class StopIterator {};
+template <typename U> class Iterator {
+ public:
+ Iterator(std::map<std::string,U*>::iterator _cur, std::map<std::string,U*>::iterator _end) : cur(_cur), end(_end) {}
+ Iterator* __iter__()
+ {
+ return this;
+ }
+ template <typename U> std::map<std::string,U*>::iterator cur;
+ template <typename U> std::map<std::string,U*>::iterator end;
+ };
+%}
+
+%include "exception.i"
+%exception Iterator::next {
+ try
+ {
+ $action // calls %extend function next() below
+ }
+ catch (StopIterator)
+ {
+ PyErr_SetString(PyExc_StopIteration, "End of iterator");
+ return NULL;
+ }
+}
+
+%extend Iterator
+{
+ std::map<std::string,U*>& next()
+ {
+ if ($self->cur != $self->end)
+ {
+ // dereference the iterator and return reference to the object,
+ // after that it increments the iterator
+ return *$self->cur++;
+ }
+ throw StopIterator();
+ }
+}
+*/
template<>
class std::map<std::string,T*>
{
PyObject* keyList = PyList_New(pysize);
std::map<std::string, T* >::const_iterator i = self->begin();
for (int j = 0; j < pysize; ++i, ++j) {
- PyList_SET_ITEM(keyList, j, PyString_FromString(i->first.c_str()));
+ PyList_SET_ITEM(keyList, j, PyUnicode_FromString(i->first.c_str()));
}
return keyList;
}
+/* Iterator __iter__()
+ {
+ // return a constructed Iterator object
+ return Iterator($self->begin(), $self->end());
+ }
+*/
+ int __len__()
+ {
+ int pysize = self->size();
+ return pysize;
+ }
}
};
%template() std::pair<std::string, T* >;
%template(tname) std::map<std::string, T* >;
%pythoncode{
-from UserDict import DictMixin
-class tname(tname,DictMixin):pass
+from collections import MutableMapping
+class tname(tname,MutableMapping):pass
tname##_swigregister(tname)
}
%enddef
