diff DEPENDENCIES/generic/include/boost/python/handle.hpp @ 16:2665513ce2d3

Add boost headers

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/DEPENDENCIES/generic/include/boost/python/handle.hpp	Tue Aug 05 11:11:38 2014 +0100
@@ -0,0 +1,264 @@
+// 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 HANDLE_DWA200269_HPP
+# define HANDLE_DWA200269_HPP
+
+# include <boost/python/detail/prefix.hpp>
+
+# include <boost/python/cast.hpp>
+# include <boost/python/errors.hpp>
+# include <boost/python/borrowed.hpp>
+# include <boost/python/handle_fwd.hpp>
+# include <boost/python/refcount.hpp>
+# include <boost/python/tag.hpp>
+# include <boost/python/detail/raw_pyobject.hpp>
+
+namespace boost { namespace python { 
+
+template <class T> struct null_ok;
+
+template <class T>
+inline null_ok<T>* allow_null(T* p)
+{
+    return (null_ok<T>*)p;
+}
+
+namespace detail
+{
+  template <class T>
+  inline T* manage_ptr(detail::borrowed<null_ok<T> >* p, int)
+  {
+      return python::xincref((T*)p);
+  }
+  
+  template <class T>
+  inline T* manage_ptr(null_ok<detail::borrowed<T> >* p, int)
+  {
+      return python::xincref((T*)p);
+  }
+  
+  template <class T>
+  inline T* manage_ptr(detail::borrowed<T>* p, long)
+  {
+      return python::incref(expect_non_null((T*)p));
+  }
+  
+  template <class T>
+  inline T* manage_ptr(null_ok<T>* p, long)
+  {
+      return (T*)p;
+  }
+  
+  template <class T>
+  inline T* manage_ptr(T* p, ...)
+  {
+      return expect_non_null(p);
+  }
+}
+
+template <class T>
+class handle
+{
+    typedef T* (handle::* bool_type )() const;
+
+ public: // types
+    typedef T element_type;
+    
+ public: // member functions
+    handle();
+    ~handle();
+
+    template <class Y>
+    explicit handle(Y* p)
+        : m_p(
+            python::upcast<T>(
+                detail::manage_ptr(p, 0)
+                )
+            )
+    {
+    }
+
+    handle& operator=(handle const& r)
+    {
+        python::xdecref(m_p);
+        m_p = python::xincref(r.m_p);
+        return *this;
+    }
+
+#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)
+
+    template<typename Y>
+    handle& operator=(handle<Y> const & r) // never throws
+    {
+        python::xdecref(m_p);
+        m_p = python::xincref(python::upcast<T>(r.get()));
+        return *this;
+    }
+
+#endif
+
+    template <typename Y>
+    handle(handle<Y> const& r)
+        : m_p(python::xincref(python::upcast<T>(r.get())))
+    {
+    }
+    
+    handle(handle const& r)
+        : m_p(python::xincref(r.m_p))
+    {
+    }
+    
+    T* operator-> () const;
+    T& operator* () const;
+    T* get() const;
+    T* release();
+    void reset();
+    
+    operator bool_type() const // never throws
+    {
+        return m_p ? &handle<T>::get : 0;
+    }
+    bool operator! () const; // never throws
+
+ public: // implementation details -- do not touch
+    // Defining this in the class body suppresses a VC7 link failure
+    inline handle(detail::borrowed_reference x)
+        : m_p(
+            python::incref(
+                downcast<T>((PyObject*)x)
+                ))
+    {
+    }
+    
+ private: // data members
+    T* m_p;
+};
+
+#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+} // namespace python
+#endif
+
+template<class T> inline T * get_pointer(python::handle<T> const & p)
+{
+    return p.get();
+}
+
+#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
+namespace python {
+#else
+
+// We don't want get_pointer above to hide the others
+using boost::get_pointer;
+
+#endif
+
+typedef handle<PyTypeObject> type_handle;
+
+//
+// Compile-time introspection
+//
+# ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+template<typename T>
+class is_handle
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = false); 
+};
+
+template<typename T>
+class is_handle<handle<T> >
+{
+ public:
+    BOOST_STATIC_CONSTANT(bool, value = true);
+};
+# else
+namespace detail
+{
+  typedef char (&yes_handle_t)[1];
+  typedef char (&no_handle_t)[2];
+      
+  no_handle_t is_handle_test(...);
+
+  template<typename T>
+  yes_handle_t is_handle_test(boost::type< handle<T> >);
+}
+
+template<typename T>
+class is_handle
+{
+ public:
+    BOOST_STATIC_CONSTANT(
+        bool, value = (
+            sizeof(detail::is_handle_test(boost::type<T>()))
+            == sizeof(detail::yes_handle_t)));
+};
+# endif
+
+//
+// implementations
+//
+template <class T>
+inline handle<T>::handle()
+    : m_p(0)
+{
+}
+
+template <class T>
+inline handle<T>::~handle()
+{
+    python::xdecref(m_p);
+}
+
+template <class T>
+inline T* handle<T>::operator->() const
+{
+    return m_p;
+}
+
+template <class T>
+inline T& handle<T>::operator*() const
+{
+    return *m_p;
+}
+
+template <class T>
+inline T* handle<T>::get() const
+{
+    return m_p;
+}
+    
+template <class T>
+inline bool handle<T>::operator!() const
+{
+    return m_p == 0;
+}
+
+template <class T>
+inline T* handle<T>::release()
+{
+    T* result = m_p;
+    m_p = 0;
+    return result;
+}
+
+template <class T>
+inline void handle<T>::reset()
+{
+    python::xdecref(m_p);
+    m_p = 0;
+}
+
+// Because get_managed_object must return a non-null PyObject*, we
+// return Py_None if the handle is null.
+template <class T>
+inline PyObject* get_managed_object(handle<T> const& h, tag_t)
+{
+    return h.get() ? python::upcast<PyObject>(h.get()) : Py_None;
+}
+
+}} // namespace boost::python
+
+
+#endif // HANDLE_DWA200269_HPP