python/include/boost/python/extract.hpp at develop · FadyEssam/python · GitHub

History

259 lines (216 loc) · 5.85 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

// 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/call_traits.hpp>

#if BOOST_WORKAROUND(BOOST_INTEL_WIN, <= 900)

# 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;

};

}

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

python/include/boost/python/extract.hpp at develop · FadyEssam/python · GitHub

Expand file tree

Breadcrumbs

extract.hpp

Latest commit

History

Breadcrumbs

extract.hpp

File metadata and controls