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