109 lines
3.0 KiB
Plaintext
109 lines
3.0 KiB
Plaintext
// 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
|