]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // Copyright David Abrahams 2002. |
2 | // Distributed under the Boost Software License, Version 1.0. (See | |
3 | // accompanying file LICENSE_1_0.txt or copy at | |
4 | // http://www.boost.org/LICENSE_1_0.txt) | |
5 | #ifndef ENUM_DWA200298_HPP | |
6 | # define ENUM_DWA200298_HPP | |
7 | ||
8 | # include <boost/python/detail/prefix.hpp> | |
9 | ||
10 | # include <boost/python/object/enum_base.hpp> | |
11 | # include <boost/python/converter/rvalue_from_python_data.hpp> | |
12 | # include <boost/python/converter/registered.hpp> | |
13 | ||
14 | namespace boost { namespace python { | |
15 | ||
16 | template <class T> | |
17 | struct enum_ : public objects::enum_base | |
18 | { | |
19 | typedef objects::enum_base base; | |
20 | ||
21 | // Declare a new enumeration type in the current scope() | |
22 | enum_(char const* name, char const* doc = 0); | |
23 | ||
24 | // Add a new enumeration value with the given name and value. | |
25 | inline enum_<T>& value(char const* name, T); | |
26 | ||
27 | // Add all of the defined enumeration values to the current scope with the | |
28 | // same names used here. | |
29 | inline enum_<T>& export_values(); | |
30 | private: | |
31 | static PyObject* to_python(void const* x); | |
32 | static void* convertible_from_python(PyObject* obj); | |
33 | static void construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data); | |
34 | }; | |
35 | ||
36 | template <class T> | |
37 | inline enum_<T>::enum_(char const* name, char const* doc ) | |
38 | : base( | |
39 | name | |
40 | , &enum_<T>::to_python | |
41 | , &enum_<T>::convertible_from_python | |
42 | , &enum_<T>::construct | |
43 | , type_id<T>() | |
44 | , doc | |
45 | ) | |
46 | { | |
47 | } | |
48 | ||
49 | // This is the conversion function that gets registered for converting | |
50 | // these enums to Python. | |
51 | template <class T> | |
52 | PyObject* enum_<T>::to_python(void const* x) | |
53 | { | |
54 | return base::to_python( | |
55 | converter::registered<T>::converters.m_class_object | |
56 | , static_cast<long>(*(T const*)x)); | |
57 | } | |
58 | ||
59 | // | |
60 | // The following two static functions serve as the elements of an | |
61 | // rvalue from_python converter for the enumeration type. | |
62 | // | |
63 | ||
64 | // This checks that a given Python object can be converted to the | |
65 | // enumeration type. | |
66 | template <class T> | |
67 | void* enum_<T>::convertible_from_python(PyObject* obj) | |
68 | { | |
69 | return PyObject_IsInstance( | |
70 | obj | |
71 | , upcast<PyObject>( | |
72 | converter::registered<T>::converters.m_class_object)) | |
73 | ||
74 | ? obj : 0; | |
75 | } | |
76 | ||
77 | // Constructs an instance of the enumeration type in the from_python | |
78 | // data. | |
79 | template <class T> | |
80 | void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data) | |
81 | { | |
82 | #if PY_VERSION_HEX >= 0x03000000 | |
83 | T x = static_cast<T>(PyLong_AS_LONG(obj)); | |
84 | #else | |
85 | T x = static_cast<T>(PyInt_AS_LONG(obj)); | |
86 | #endif | |
87 | void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes; | |
88 | new (storage) T(x); | |
89 | data->convertible = storage; | |
90 | } | |
91 | ||
92 | template <class T> | |
93 | inline enum_<T>& enum_<T>::value(char const* name, T x) | |
94 | { | |
95 | this->add_value(name, static_cast<long>(x)); | |
96 | return *this; | |
97 | } | |
98 | ||
99 | template <class T> | |
100 | inline enum_<T>& enum_<T>::export_values() | |
101 | { | |
102 | this->base::export_values(); | |
103 | return *this; | |
104 | } | |
105 | ||
106 | }} // namespace boost::python | |
107 | ||
108 | #endif // ENUM_DWA200298_HPP |