conversion.hpp

Go to the documentation of this file.

// mds_utils/python/conversion.hpp
// 
// Copyright (c) 2014 - Michele De Stefano (micdestefano@users.sourceforge.net)
// 
// Distributed under the MIT License (See accompanying file LICENSE)

#ifndef MDS_UTILS_PYTHON_CONVERSION_HPP_INCLUDED
#define MDS_UTILS_PYTHON_CONVERSION_HPP_INCLUDED

#include <Python.h>
#include <stdexcept>
#include <string>
#include <complex>
#include <boost/preprocessor/seq/for_each.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/numeric/conversion/cast.hpp>
//#include <mds_utils/python/obj.hpp>

namespace mds_utils {
    namespace python {
        
template<class T>
T get(PyObject *po);


PyObject* to_python(void);



template<>
inline PyObject* get<PyObject*>(PyObject *po) {
    return po;
}

inline PyObject* to_python(PyObject *po) {
    Py_XINCREF(po);
    return po;
}


#define SEQ_TYPE_PY_TYPE_FUN_AS \
            ((long,PyInt_AsLong,PyInt_FromLong))    \
            ((double,PyFloat_AsDouble,PyFloat_FromDouble))

#define SEQ_TYPE_PY_TYPE_FUN_AS_CAST    \
            ((short,PyInt_AsLong,PyInt_FromLong,long))  \
            ((unsigned short,PyInt_AsLong,PyInt_FromLong,long)) \
            ((int,PyInt_AsLong,PyInt_FromLong,long))    \
            ((unsigned int,PyInt_AsLong,PyInt_FromLong,long))   \
            ((unsigned long,PyInt_AsLong,PyInt_FromLong,long))  \
            ((long long,PyInt_AsLong,PyInt_FromLong,long))  \
            ((unsigned long long,PyInt_AsLong,PyInt_FromLong,long)) \
            ((float,PyFloat_AsDouble,PyFloat_FromDouble,double))

#define GET_SPEC_GEN(r,data,elem)   \
    template<>  \
    inline BOOST_PP_TUPLE_ELEM(3,0,elem) get< BOOST_PP_TUPLE_ELEM(3,0,elem) >(PyObject *po) {   \
        BOOST_PP_TUPLE_ELEM(3,0,elem)       retval(BOOST_PP_TUPLE_ELEM(3,1,elem)(po));  \
        \
        if (PyErr_Occurred() != NULL) { \
            throw std::invalid_argument("Cannot get a " BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(3,0,elem)) " value");    \
        }   \
        \
        return retval;  \
    }   \
    \
    inline PyObject* to_python(BOOST_PP_TUPLE_ELEM(3,0,elem) val) { \
        PyObject*   retval(BOOST_PP_TUPLE_ELEM(3,2,elem)(val)); \
        \
        if (retval == NULL) throw std::invalid_argument("Cannot convert " BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(3,0,elem)) " to Python");  \
        \
        return retval;  \
    }


#define GET_SPEC_GEN_CAST(r,data,elem)  \
    template<>  \
    inline BOOST_PP_TUPLE_ELEM(4,0,elem) get< BOOST_PP_TUPLE_ELEM(4,0,elem) >(PyObject *po) {   \
        BOOST_PP_TUPLE_ELEM(4,0,elem)       retval(boost::numeric_cast< BOOST_PP_TUPLE_ELEM(4,0,elem) >(BOOST_PP_TUPLE_ELEM(4,1,elem)(po)));    \
        \
        if (PyErr_Occurred() != NULL) { \
            throw std::invalid_argument("Cannot get a " BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(4,0,elem)) " value");    \
        }   \
        \
        return retval;  \
    }   \
    \
    inline PyObject* to_python(const BOOST_PP_TUPLE_ELEM(4,0,elem) val) {   \
        PyObject*   retval(BOOST_PP_TUPLE_ELEM(4,2,elem)(boost::numeric_cast< BOOST_PP_TUPLE_ELEM(4,3,elem) >(val)));   \
        \
        if (retval == NULL) throw std::invalid_argument("Cannot convert " BOOST_PP_STRINGIZE(BOOST_PP_TUPLE_ELEM(4,0,elem)) " to Python");  \
        \
        return retval;  \
    }

BOOST_PP_SEQ_FOR_EACH(GET_SPEC_GEN,~,SEQ_TYPE_PY_TYPE_FUN_AS)
BOOST_PP_SEQ_FOR_EACH(GET_SPEC_GEN_CAST,~,SEQ_TYPE_PY_TYPE_FUN_AS_CAST)


template<>
inline const char* get<const char*>(PyObject *po) {
    
    const char  *retval(const_cast<const char*>(PyString_AsString(po)));
    
    if (PyErr_Occurred() != NULL) {
        throw std::invalid_argument("Cannot get a const char* value");  \
    }
    
    return retval;
}


template<>
inline std::string get<std::string>(PyObject *po) {
    std::string     retval(get<char*>(po));
    
    if (PyErr_Occurred() != NULL) {
        throw std::invalid_argument("Cannot get a std::string value");
    }
    
    return retval;
}



inline PyObject* to_python(const char* str) {
    PyObject *retval(PyString_FromString(str));
    
    if (retval == NULL) throw std::invalid_argument("Cannot convert a const char* to Python");
    
    return retval;
}


inline PyObject* to_python(const std::string& str) {

    PyObject*   retval(PyString_FromString(str.c_str()));
    
    if (retval == NULL) throw std::invalid_argument("Cannot convert a std::string to Python");
    
    return retval;
}


template<>
inline std::complex<double> get< std::complex<double> >(PyObject *po) {
    
    std::complex<double>    retval(
                                PyComplex_RealAsDouble(po),
                                PyComplex_ImagAsDouble(po)
                            );
    
    if (PyErr_Occurred() != NULL) {
        throw std::invalid_argument("Cannot get a std::complex<double> value"); \
    }
    
    return retval;
}


inline PyObject* to_python(const std::complex<double>& val) {

    PyObject*   retval(PyComplex_FromDoubles(val.real(),val.imag()));
    
    if (retval == NULL) {
        throw std::invalid_argument("Cannot convert a std::complex<double> to Python");
    }
    
    return retval;
}

// WARNING: I REMOVE THE CONVERSIONS BELOW, BECAUSE IN STANDARD PYTHON complex<float> numbers do not exist
// NumPy provides them.
//template<>
//inline std::complex<float> get< std::complex<float> >(PyObject *po) {
//
//  std::complex<float>     retval(
//                              boost::numeric_cast<float>(PyComplex_RealAsDouble(po)),
//                              boost::numeric_cast<float>(PyComplex_ImagAsDouble(po))
//                          );
//
//  if (PyErr_Occurred() != NULL) {
//      throw std::invalid_argument("Cannot get a std::complex<float> value");
//  }
//
//  return retval;
//}
//
//
//inline PyObject* to_python(const std::complex<float>& val) {
//
//  PyObject*   retval(PyComplex_FromDoubles(
//                              static_cast<double>(val.real()),
//                              static_cast<double>(val.imag())
//                          )
//                      );
//
//  if (retval == NULL) {
//      throw std::invalid_argument("Cannot convert a std::complex<float> to Python");
//  }
//
//  return retval;
//}



    }   // namespace python
}   // namespace mds_utils

#endif