Added boost header

test/external/boost/python/extract.hpp

@@ -0,0 +1,261 @@
+// 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 EXTRACT_DWA200265_HPP
+# define EXTRACT_DWA200265_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/converter/object_manager.hpp>
+# include <boost/python/converter/from_python.hpp>
+# include <boost/python/converter/rvalue_from_python_data.hpp>
+# include <boost/python/converter/registered.hpp>
+# include <boost/python/converter/registered_pointee.hpp>
+
+# include <boost/python/object_core.hpp>
+# include <boost/python/refcount.hpp>
+
+# include <boost/python/detail/copy_ctor_mutates_rhs.hpp>
+# include <boost/python/detail/void_ptr.hpp>
+# include <boost/python/detail/void_return.hpp>
+# include <boost/utility.hpp>
+# include <boost/call_traits.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)
+// workaround for VC++ 6.x or 7.0
+# define BOOST_EXTRACT_WORKAROUND ()
+#else
+# define BOOST_EXTRACT_WORKAROUND
+#endif
+
+namespace boost { namespace python {
+
+namespace api
+{
+  class object;
+}
+
+namespace converter
+{
+  template <class Ptr>
+  struct extract_pointer
+  {
+      typedef Ptr result_type;
+      extract_pointer(PyObject*);
+      
+      bool check() const;
+      Ptr operator()() const;
+      
+   private:
+      PyObject* m_source;
+      void* m_result;
+  };
+  
+  template <class Ref>
+  struct extract_reference
+  {
+      typedef Ref result_type;
+      extract_reference(PyObject*);
+      
+      bool check() const;
+      Ref operator()() const;
+      
+   private:
+      PyObject* m_source;
+      void* m_result;
+  };
+  
+  template <class T>
+  struct extract_rvalue : private noncopyable
+  {
+      typedef typename mpl::if_<
+          python::detail::copy_ctor_mutates_rhs<T>
+        , T&
+        , typename call_traits<T>::param_type
+      >::type result_type;
+
+      extract_rvalue(PyObject*);
+
+      bool check() const;
+      result_type operator()() const;
+   private:
+      PyObject* m_source;
+      mutable rvalue_from_python_data<T> m_data;
+  };
+  
+  template <class T>
+  struct extract_object_manager
+  {
+      typedef T result_type;
+      extract_object_manager(PyObject*);
+
+      bool check() const;
+      result_type operator()() const;
+   private:
+      PyObject* m_source;
+  };
+  
+  template <class T>
+  struct select_extract
+  {
+      BOOST_STATIC_CONSTANT(
+          bool, obj_mgr = is_object_manager<T>::value);
+
+      BOOST_STATIC_CONSTANT(
+          bool, ptr = is_pointer<T>::value);
+    
+      BOOST_STATIC_CONSTANT(
+          bool, ref = is_reference<T>::value);
+
+      typedef typename mpl::if_c<
+          obj_mgr
+          , extract_object_manager<T>
+          , typename mpl::if_c<
+              ptr
+              , extract_pointer<T>
+              , typename mpl::if_c<
+                  ref
+                  , extract_reference<T>
+                  , extract_rvalue<T>
+                >::type
+            >::type
+         >::type type;
+  };
+}
+
+template <class T>
+struct extract
+    : converter::select_extract<T>::type
+{
+ private:
+    typedef typename converter::select_extract<T>::type base;
+ public:
+    typedef typename base::result_type result_type;
+    
+    operator result_type() const
+    {
+        return (*this)();
+    }
+    
+    extract(PyObject*);
+    extract(api::object const&);
+};
+
+//
+// Implementations
+//
+template <class T>
+inline extract<T>::extract(PyObject* o)
+    : base(o)
+{
+}
+
+template <class T>
+inline extract<T>::extract(api::object const& o)
+    : base(o.ptr())
+{
+}
+
+namespace converter
+{
+  template <class T>
+  inline extract_rvalue<T>::extract_rvalue(PyObject* x)
+      : m_source(x)
+      , m_data(
+          (rvalue_from_python_stage1)(x, registered<T>::converters)
+          )
+  {
+  }
+  
+  template <class T>
+  inline bool
+  extract_rvalue<T>::check() const
+  {
+      return m_data.stage1.convertible;
+  }
+
+  template <class T>
+  inline typename extract_rvalue<T>::result_type
+  extract_rvalue<T>::operator()() const
+  {
+      return *(T*)(
+          // Only do the stage2 conversion once
+          m_data.stage1.convertible ==  m_data.storage.bytes
+             ? m_data.storage.bytes
+             : (rvalue_from_python_stage2)(m_source, m_data.stage1, registered<T>::converters)
+          );
+  }
+
+  template <class Ref>
+  inline extract_reference<Ref>::extract_reference(PyObject* obj)
+      : m_source(obj)
+      , m_result(
+          (get_lvalue_from_python)(obj, registered<Ref>::converters)
+          )
+  {
+  }
+
+  template <class Ref>
+  inline bool extract_reference<Ref>::check() const
+  {
+      return m_result != 0;
+  }
+
+  template <class Ref>
+  inline Ref extract_reference<Ref>::operator()() const
+  {
+      if (m_result == 0)
+          (throw_no_reference_from_python)(m_source, registered<Ref>::converters);
+      
+      return python::detail::void_ptr_to_reference(m_result, (Ref(*)())0);
+  }
+
+  template <class Ptr>
+  inline extract_pointer<Ptr>::extract_pointer(PyObject* obj)
+      : m_source(obj)
+      , m_result(
+          obj == Py_None ? 0 : (get_lvalue_from_python)(obj, registered_pointee<Ptr>::converters)
+          )
+  {
+  }
+
+  template <class Ptr>
+  inline bool extract_pointer<Ptr>::check() const
+  {
+      return m_source == Py_None || m_result != 0;
+  }
+
+  template <class Ptr>
+  inline Ptr extract_pointer<Ptr>::operator()() const
+  {
+      if (m_result == 0 && m_source != Py_None)
+          (throw_no_pointer_from_python)(m_source, registered_pointee<Ptr>::converters);
+      
+      return Ptr(m_result);
+  }
+
+  template <class T>
+  inline extract_object_manager<T>::extract_object_manager(PyObject* obj)
+      : m_source(obj)
+  {
+  }
+
+  template <class T>
+  inline bool extract_object_manager<T>::check() const
+  {
+      return object_manager_traits<T>::check(m_source);
+  }
+
+  template <class T>
+  inline T extract_object_manager<T>::operator()() const
+  {
+      return T(
+          object_manager_traits<T>::adopt(python::incref(m_source))
+          );
+  }
+}
+  
+}} // namespace boost::python::converter
+
+#endif // EXTRACT_DWA200265_HPP