Imported Upstream version 1.49.0upstream/1.49.0

1 files changed, 108 insertions, 0 deletions

diff --git a/boost/python/enum.hpp b/boost/python/enum.hpp
new file mode 100644
index 0000000000..9631a0edc8
--- /dev/null
+++ b/boost/python/enum.hpp
@@ -0,0 +1,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