// 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