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