This repository was archived by the owner on Mar 7, 2026. It is now read-only.
Repository navigation
Expand file tree
/
Copy pathenum.hpp
More file actions
108 lines (91 loc) · 2.93 KB
/
Copy pathenum.hpp
File metadata and controls
108 lines (91 loc) · 2.93 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
// 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