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

# include 
# include 
# include 
# include 
# include 

# include 
# include 

# include 
# include 
# include 
# include 

#if BOOST_WORKAROUND(BOOST_INTEL_WIN, ::type result_type;

      extract_rvalue(PyObject*);

      bool check() const;
      result_type operator()() const;
   private:
      PyObject* m_source;
      mutable rvalue_from_python_data m_data;
  };
  
  template 
  struct extract_object_manager
  {
      typedef T result_type;
      extract_object_manager(PyObject*);

      bool check() const;
      result_type operator()() const;
   private:
      PyObject* m_source;
  };
  
  template 
  struct select_extract
  {
      BOOST_STATIC_CONSTANT(
          bool, obj_mgr = is_object_manager::value);

      BOOST_STATIC_CONSTANT(
          bool, ptr = is_pointer::value);
    
      BOOST_STATIC_CONSTANT(
          bool, ref = is_reference::value);

      typedef typename mpl::if_c<
          obj_mgr
          , extract_object_manager
          , typename mpl::if_c<
              ptr
              , extract_pointer
              , typename mpl::if_c<
                  ref
                  , extract_reference
                  , extract_rvalue
                >::type
            >::type
         >::type type;
  };
}

template 
struct extract
    : converter::select_extract::type
{
 private:
    typedef typename converter::select_extract::type base;
 public:
    typedef typename base::result_type result_type;
    
    operator result_type() const
    {
        return (*this)();
    }
    
    extract(PyObject*);
    extract(api::object const&);
};

//
// Implementations
//
template 
inline extract::extract(PyObject* o)
    : base(o)
{
}

template 
inline extract::extract(api::object const& o)
    : base(o.ptr())
{
}

namespace converter
{
  template 
  inline extract_rvalue::extract_rvalue(PyObject* x)
      : m_source(x)
      , m_data(
          (rvalue_from_python_stage1)(x, registered::converters)
          )
  {
  }
  
  template 
  inline bool
  extract_rvalue::check() const
  {
      return m_data.stage1.convertible;
  }

  template 
  inline typename extract_rvalue::result_type
  extract_rvalue::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::converters)
          );
  }

  template 
  inline extract_reference::extract_reference(PyObject* obj)
      : m_source(obj)
      , m_result(
          (get_lvalue_from_python)(obj, registered::converters)
          )
  {
  }

  template 
  inline bool extract_reference::check() const
  {
      return m_result != 0;
  }

  template 
  inline Ref extract_reference::operator()() const
  {
      if (m_result == 0)
          (throw_no_reference_from_python)(m_source, registered::converters);
      
      return python::detail::void_ptr_to_reference(m_result, (Ref(*)())0);
  }

  template 
  inline extract_pointer::extract_pointer(PyObject* obj)
      : m_source(obj)
      , m_result(
          obj == Py_None ? 0 : (get_lvalue_from_python)(obj, registered_pointee::converters)
          )
  {
  }

  template 
  inline bool extract_pointer::check() const
  {
      return m_source == Py_None || m_result != 0;
  }

  template 
  inline Ptr extract_pointer::operator()() const
  {
      if (m_result == 0 && m_source != Py_None)
          (throw_no_pointer_from_python)(m_source, registered_pointee::converters);
      
      return Ptr(m_result);
  }

  template 
  inline extract_object_manager::extract_object_manager(PyObject* obj)
      : m_source(obj)
  {
  }

  template 
  inline bool extract_object_manager::check() const
  {
      return object_manager_traits::check(m_source);
  }

  template 
  inline T extract_object_manager::operator()() const
  {
      return T(
          object_manager_traits::adopt(python::incref(m_source))
          );
  }
}
  
}} // namespace boost::python::converter

#endif // EXTRACT_DWA200265_HPP