// Copyright David Abrahams 2002. | |
// Distributed under the Boost Software License, Version 1.0. (See | |
// accompanying file LICENSE_1_0.txt or copy at | |
// http://www.boost.org/LICENSE_1_0.txt) | |
#ifndef ENUM_DWA200298_HPP | |
# define ENUM_DWA200298_HPP | |
# include <boost/python/detail/prefix.hpp> | |
# include <boost/python/object/enum_base.hpp> | |
# include <boost/python/converter/rvalue_from_python_data.hpp> | |
# include <boost/python/converter/registered.hpp> | |
namespace boost { namespace python { | |
template <class T> | |
struct enum_ : public objects::enum_base | |
{ | |
typedef objects::enum_base base; | |
// Declare a new enumeration type in the current scope() | |
enum_(char const* name, char const* doc = 0); | |
// Add a new enumeration value with the given name and value. | |
inline enum_<T>& value(char const* name, T); | |
// Add all of the defined enumeration values to the current scope with the | |
// same names used here. | |
inline enum_<T>& export_values(); | |
private: | |
static PyObject* to_python(void const* x); | |
static void* convertible_from_python(PyObject* obj); | |
static void construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data); | |
}; | |
template <class T> | |
inline enum_<T>::enum_(char const* name, char const* doc ) | |
: base( | |
name | |
, &enum_<T>::to_python | |
, &enum_<T>::convertible_from_python | |
, &enum_<T>::construct | |
, type_id<T>() | |
, doc | |
) | |
{ | |
} | |
// This is the conversion function that gets registered for converting | |
// these enums to Python. | |
template <class T> | |
PyObject* enum_<T>::to_python(void const* x) | |
{ | |
return base::to_python( | |
converter::registered<T>::converters.m_class_object | |
, static_cast<long>(*(T const*)x)); | |
} | |
// | |
// 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* enum_<T>::convertible_from_python(PyObject* obj) | |
{ | |
return PyObject_IsInstance( | |
obj | |
, upcast<PyObject>( | |
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 enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data) | |
{ | |
#if PY_VERSION_HEX >= 0x03000000 | |
T x = static_cast<T>(PyLong_AS_LONG(obj)); | |
#else | |
T x = static_cast<T>(PyInt_AS_LONG(obj)); | |
#endif | |
void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes; | |
new (storage) T(x); | |
data->convertible = storage; | |
} | |
template <class T> | |
inline enum_<T>& enum_<T>::value(char const* name, T x) | |
{ | |
this->add_value(name, static_cast<long>(x)); | |
return *this; | |
} | |
template <class T> | |
inline enum_<T>& enum_<T>::export_values() | |
{ | |
this->base::export_values(); | |
return *this; | |
} | |
}} // namespace boost::python | |
#endif // ENUM_DWA200298_HPP |