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

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

    : base(

        name

        , &enum_<T>::to_python

        , &enum_<T>::convertible_from_python

        , &enum_<T>::construct

        , type_id<T>())

{

}

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

{

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

    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