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);

    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)

    38     : base(

    39         name

    40         , &enum_<T>::to_python

    41         , &enum_<T>::convertible_from_python

    42         , &enum_<T>::construct

    43         , type_id<T>())

    44 {

    45 }

    46 

    47 // This is the conversion function that gets registered for converting

    48 // these enums to Python.

    49 template <class T>

    50 PyObject* enum_<T>::to_python(void const* x)

    51 {

    52     return base::to_python(

    53         converter::registered<T>::converters.m_class_object

    54         , static_cast<long>(*(T const*)x));

    55 }

    56 

    57 //

    58 // The following two static functions serve as the elements of an

    59 // rvalue from_python converter for the enumeration type.

    60 //

    61 

    62 // This checks that a given Python object can be converted to the

    63 // enumeration type.

    64 template <class T>

    65 void* enum_<T>::convertible_from_python(PyObject* obj)

    66 {

    67     return PyObject_IsInstance(

    68         obj

    69         , upcast<PyObject>(

    70             converter::registered<T>::converters.m_class_object))

    71         

    72         ? obj : 0;

    73 }

    74 

    75 // Constructs an instance of the enumeration type in the from_python

    76 // data.

    77 template <class T>

    78 void enum_<T>::construct(PyObject* obj, converter::rvalue_from_python_stage1_data* data)

    79 {

    80     T x = static_cast<T>(PyInt_AS_LONG(obj));

    81     void* const storage = ((converter::rvalue_from_python_storage<T>*)data)->storage.bytes;

    82     new (storage) T(x);

    83     data->convertible = storage;

    84 }

    85 

    86 template <class T>

    87 inline enum_<T>& enum_<T>::value(char const* name, T x)

    88 {

    89     this->add_value(name, static_cast<long>(x));

    90     return *this;

    91 }

    92 

    93 template <class T>

    94 inline enum_<T>& enum_<T>::export_values()

    95 {

    96     this->base::export_values();

    97     return *this;

    98 }

    99 

   100 }} // namespace boost::python

   101 

   102 #endif // ENUM_DWA200298_HPP