/usr/include/boost/python/enum.hpp is in libboost1.55-dev 1.55.0+dfsg-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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
|