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

# include 
# include 
# include 
# include 
# include 
# include 
# include 

namespace boost { namespace python { 

template  struct null_ok;

template 
inline null_ok* allow_null(T* p)
{
    return (null_ok*)p;
}

namespace detail
{
  template 
  inline T* manage_ptr(detail::borrowed* p, int)
  {
      return python::xincref((T*)p);
  }
  
  template 
  inline T* manage_ptr(null_ok* p, int)
  {
      return python::xincref((T*)p);
  }
  
  template 
  inline T* manage_ptr(detail::borrowed* p, long)
  {
      return python::incref(expect_non_null((T*)p));
  }
  
  template 
  inline T* manage_ptr(null_ok* p, long)
  {
      return (T*)p;
  }
  
  template 
  inline T* manage_ptr(T* p, ...)
  {
      return expect_non_null(p);
  }
}

template 
class handle
{
    typedef T* (handle::* bool_type )() const;

 public: // types
    typedef T element_type;
    
 public: // member functions
    handle();
    ~handle();

    template 
    explicit handle(Y* p)
        : m_p(
            python::upcast(
                detail::manage_ptr(p, 0)
                )
            )
    {
    }

    handle& operator=(handle const& r)
    {
        python::xdecref(m_p);
        m_p = python::xincref(r.m_p);
        return *this;
    }

    template
    handle& operator=(handle const & r) // never throws
    {
        python::xdecref(m_p);
        m_p = python::xincref(python::upcast(r.get()));
        return *this;
    }

    template 
    handle(handle const& r)
        : m_p(python::xincref(python::upcast(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::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((PyObject*)x)
                ))
    {
    }
    
 private: // data members
    T* m_p;
};

#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
} // namespace python
#endif

template inline T * get_pointer(python::handle 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 type_handle;

//
// Compile-time introspection
//
template
class is_handle
{
 public:
    BOOST_STATIC_CONSTANT(bool, value = false); 
};

template
class is_handle
{
 public:
    BOOST_STATIC_CONSTANT(bool, value = true);
};

//
// implementations
//
template 
inline handle::handle()
    : m_p(0)
{
}

template 
inline handle::~handle()
{
    python::xdecref(m_p);
}

template 
inline T* handle::operator->() const
{
    return m_p;
}

template 
inline T& handle::operator*() const
{
    return *m_p;
}

template 
inline T* handle::get() const
{
    return m_p;
}
    
template 
inline bool handle::operator!() const
{
    return m_p == 0;
}

template 
inline T* handle::release()
{
    T* result = m_p;
    m_p = 0;
    return result;
}

template 
inline void handle::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 
inline PyObject* get_managed_object(handle const& h, tag_t)
{
    return h.get() ? python::upcast(h.get()) : Py_None;
}

}} // namespace boost::python


#endif // HANDLE_DWA200269_HPP