You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
108 lines
2.9 KiB
108 lines
2.9 KiB
// 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
|
|
|