boost/python/extract.hpp

   1 // Copyright David Abrahams 2002.
   2 // Distributed under the Boost Software License, Version 1.0. (See
   3 // accompanying file LICENSE_1_0.txt or copy at
   4 // http://www.boost.org/LICENSE_1_0.txt)
   5 #ifndef EXTRACT_DWA200265_HPP
   6 # define EXTRACT_DWA200265_HPP
   7
   8 # include <boost/python/detail/prefix.hpp>
   9
  10 # include <boost/python/converter/object_manager.hpp>
  11 # include <boost/python/converter/from_python.hpp>
  12 # include <boost/python/converter/rvalue_from_python_data.hpp>
  13 # include <boost/python/converter/registered.hpp>
  14 # include <boost/python/converter/registered_pointee.hpp>
  15
  16 # include <boost/python/object_core.hpp>
  17 # include <boost/python/refcount.hpp>
  18
  19 # include <boost/python/detail/copy_ctor_mutates_rhs.hpp>
  20 # include <boost/python/detail/void_ptr.hpp>
  21 # include <boost/python/detail/void_return.hpp>
  22 # include <boost/utility.hpp>
  23 # include <boost/call_traits.hpp>
  24
  25 #if BOOST_WORKAROUND(BOOST_MSVC, <= 1300) || BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)
  26 // workaround for VC++ 6.x or 7.0
  27 # define BOOST_EXTRACT_WORKAROUND ()
  28 #else
  29 # define BOOST_EXTRACT_WORKAROUND
  30 #endif
  31
  32 namespace boost { namespace python {
  33
  34 namespace api
  35 {
  36   class object;
  37 }
  38
  39 namespace converter
  40 {
  41   template <class Ptr>
  42   struct extract_pointer
  43   {
  44       typedef Ptr result_type;
  45       extract_pointer(PyObject*);
  46
  47       bool check() const;
  48       Ptr operator()() const;
  49
  50    private:
  51       PyObject* m_source;
  52       void* m_result;
  53   };
  54
  55   template <class Ref>
  56   struct extract_reference
  57   {
  58       typedef Ref result_type;
  59       extract_reference(PyObject*);
  60
  61       bool check() const;
  62       Ref operator()() const;
  63
  64    private:
  65       PyObject* m_source;
  66       void* m_result;
  67   };
  68
  69   template <class T>
  70   struct extract_rvalue : private noncopyable
  71   {
  72       typedef typename mpl::if_<
  73           python::detail::copy_ctor_mutates_rhs<T>
  74         , T&
  75         , typename call_traits<T>::param_type
  76       >::type result_type;
  77
  78       extract_rvalue(PyObject*);
  79
  80       bool check() const;
  81       result_type operator()() const;
  82    private:
  83       PyObject* m_source;
  84       mutable rvalue_from_python_data<T> m_data;
  85   };
  86
  87   template <class T>
  88   struct extract_object_manager
  89   {
  90       typedef T result_type;
  91       extract_object_manager(PyObject*);
  92
  93       bool check() const;
  94       result_type operator()() const;
  95    private:
  96       PyObject* m_source;
  97   };
  98
  99   template <class T>
 100   struct select_extract
 101   {
 102       BOOST_STATIC_CONSTANT(
 103           bool, obj_mgr = is_object_manager<T>::value);
 104
 105       BOOST_STATIC_CONSTANT(
 106           bool, ptr = is_pointer<T>::value);
 107
 108       BOOST_STATIC_CONSTANT(
 109           bool, ref = is_reference<T>::value);
 110
 111       typedef typename mpl::if_c<
 112           obj_mgr
 113           , extract_object_manager<T>
 114           , typename mpl::if_c<
 115               ptr
 116               , extract_pointer<T>
 117               , typename mpl::if_c<
 118                   ref
 119                   , extract_reference<T>
 120                   , extract_rvalue<T>
 121                 >::type
 122             >::type
 123          >::type type;
 124   };
 125 }
 126
 127 template <class T>
 128 struct extract
 129     : converter::select_extract<T>::type
 130 {
 131  private:
 132     typedef typename converter::select_extract<T>::type base;
 133  public:
 134     typedef typename base::result_type result_type;
 135
 136     operator result_type() const
 137     {
 138         return (*this)();
 139     }
 140
 141     extract(PyObject*);
 142     extract(api::object const&);
 143 };
 144
 145 //
 146 // Implementations
 147 //
 148 template <class T>
 149 inline extract<T>::extract(PyObject* o)
 150     : base(o)
 151 {
 152 }
 153
 154 template <class T>
 155 inline extract<T>::extract(api::object const& o)
 156     : base(o.ptr())
 157 {
 158 }
 159
 160 namespace converter
 161 {
 162   template <class T>
 163   inline extract_rvalue<T>::extract_rvalue(PyObject* x)
 164       : m_source(x)
 165       , m_data(
 166           (rvalue_from_python_stage1)(x, registered<T>::converters)
 167           )
 168   {
 169   }
 170
 171   template <class T>
 172   inline bool
 173   extract_rvalue<T>::check() const
 174   {
 175       return m_data.stage1.convertible;
 176   }
 177
 178   template <class T>
 179   inline typename extract_rvalue<T>::result_type
 180   extract_rvalue<T>::operator()() const
 181   {
 182       return *(T*)(
 183           // Only do the stage2 conversion once
 184           m_data.stage1.convertible ==  m_data.storage.bytes
 185              ? m_data.storage.bytes
 186              : (rvalue_from_python_stage2)(m_source, m_data.stage1, registered<T>::converters)
 187           );
 188   }
 189
 190   template <class Ref>
 191   inline extract_reference<Ref>::extract_reference(PyObject* obj)
 192       : m_source(obj)
 193       , m_result(
 194           (get_lvalue_from_python)(obj, registered<Ref>::converters)
 195           )
 196   {
 197   }
 198
 199   template <class Ref>
 200   inline bool extract_reference<Ref>::check() const
 201   {
 202       return m_result != 0;
 203   }
 204
 205   template <class Ref>
 206   inline Ref extract_reference<Ref>::operator()() const
 207   {
 208       if (m_result == 0)
 209           (throw_no_reference_from_python)(m_source, registered<Ref>::converters);
 210
 211       return python::detail::void_ptr_to_reference(m_result, (Ref(*)())0);
 212   }
 213
 214   template <class Ptr>
 215   inline extract_pointer<Ptr>::extract_pointer(PyObject* obj)
 216       : m_source(obj)
 217       , m_result(
 218           obj == Py_None ? 0 : (get_lvalue_from_python)(obj, registered_pointee<Ptr>::converters)
 219           )
 220   {
 221   }
 222
 223   template <class Ptr>
 224   inline bool extract_pointer<Ptr>::check() const
 225   {
 226       return m_source == Py_None || m_result != 0;
 227   }
 228
 229   template <class Ptr>
 230   inline Ptr extract_pointer<Ptr>::operator()() const
 231   {
 232       if (m_result == 0 && m_source != Py_None)
 233           (throw_no_pointer_from_python)(m_source, registered_pointee<Ptr>::converters);
 234
 235       return Ptr(m_result);
 236   }
 237
 238   template <class T>
 239   inline extract_object_manager<T>::extract_object_manager(PyObject* obj)
 240       : m_source(obj)
 241   {
 242   }
 243
 244   template <class T>
 245   inline bool extract_object_manager<T>::check() const
 246   {
 247       return object_manager_traits<T>::check(m_source);
 248   }
 249
 250   template <class T>
 251   inline T extract_object_manager<T>::operator()() const
 252   {
 253       return T(
 254           object_manager_traits<T>::adopt(python::incref(m_source))
 255           );
 256   }
 257 }
 258
 259 }} // namespace boost::python::converter
 260
 261 #endif // EXTRACT_DWA200265_HPP