PythonEnumUtils.h

Go to the documentation of this file.

// PythonEnumUtils.h:
// ------------------
//

#ifndef __PYIPSDKBASE_PYTHONENUMUTILS_H__
#define __PYIPSDKBASE_PYTHONENUMUTILS_H__

#include <boost/python/enum.hpp>
#include <boost/python/implicit.hpp>

namespace ipsdk {
namespace python {


template <class T>
struct ipsdkEnum_ : public boost::python::objects::enum_base
{
    typedef boost::python::objects::enum_base base;

    // Declare a new enumeration type in the current scope()
    ipsdkEnum_(char const* name, char const* doc = 0);

    // Add a new enumeration value with the given name and value.
    inline ipsdkEnum_<T>& value(char const* name, T);

    // Add all of the defined enumeration values to the current scope with the
    // same names used here.
    inline ipsdkEnum_<T>& export_values();
private:
    static PyObject* to_python(void const* x);
    static void* convertible_from_python(PyObject* obj);
    static void construct(PyObject* obj, boost::python::converter::rvalue_from_python_stage1_data* data);
};

template <class T>
inline ipsdkEnum_<T>::ipsdkEnum_(char const* name, char const* doc)
    : base(
    name
    , &ipsdkEnum_<T>::to_python
    , &ipsdkEnum_<T>::convertible_from_python
    , &ipsdkEnum_<T>::construct
    , boost::python::type_id<T>()
    , doc
    )
{
}

// This is the conversion function that gets registered for converting
// these enums to Python.
template <class T>
PyObject* ipsdkEnum_<T>::to_python(void const* x)
{
    return base::to_python(
        boost::python::converter::registered<T>::converters.m_class_object
        , ((T const*)x)->value());
}

//
// The following two static functions serve as the elements of an
// rvalue from_python converter for the enumeration type.
//

// This checks that a given Python object can be converted to the
// enumeration type.
template <class T>
void* ipsdkEnum_<T>::convertible_from_python(PyObject* obj)
{
    return PyObject_IsInstance(
        obj
        , boost::python::upcast<PyObject>(
        boost::python::converter::registered<T>::converters.m_class_object))

        ? obj : 0;
}

// Constructs an instance of the enumeration type in the from_python
// data.
template <class T>
void ipsdkEnum_<T>::construct(PyObject* obj, boost::python::converter::rvalue_from_python_stage1_data* data)
{
#if PY_VERSION_HEX >= 0x03000000
    T x = static_cast<typename T::domain>(PyLong_AS_LONG(obj));
#else
    T x = static_cast<typename T::domain>(PyInt_AS_LONG(obj));
#endif
    void* const storage = ((boost::python::converter::rvalue_from_python_storage<T>*)data)->storage.bytes;
    new (storage)T(x);
    data->convertible = storage;
}

template <class T>
inline ipsdkEnum_<T>& ipsdkEnum_<T>::value(char const* name, T x)
{
    this->add_value(name, x.value());
    return *this;
}

template <class T>
inline ipsdkEnum_<T>& ipsdkEnum_<T>::export_values()
{
    this->base::export_values();
    return *this;
}


template <typename EnumType>
void
ipsdkToPythonEnum(const char* enumName)
{
    // registration of all enumerates values
    ipsdkEnum_<EnumType> curEnum(enumName);
    typename EnumType::const_iterator iter = EnumType::begin();
    while (iter != EnumType::end()) {

        curEnum.value(iter->str(), static_cast<typename EnumType::domain>(iter->value()));
        ++iter;
    }
    curEnum.export_values();
    boost::python::implicitly_convertible<typename EnumType::domain, EnumType>();
}


} // end of namespace python
} // end of namespace ipsdk

#endif // __PYIPSDKBASE_PYTHONENUMUTILS_H__