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