GeezerVison is showing github.com — python/include/boost/python/to_python_value.hpp at develop · o01eg/python

Expand file tree

to_python_value.hpp

Copy path

More file actions

Latest commit

History

177 lines (148 loc) · 5.44 KB

to_python_value.hpp

Copy path

File metadata and controls

177 lines (148 loc) · 5.44 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

// Copyright David Abrahams 2002.

// Copyright Stefan Seefeld 2016.

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

#define boost_python_to_python_value_hpp_

#include <boost/python/detail/prefix.hpp>

#include <boost/python/refcount.hpp>

#include <boost/python/tag.hpp>

#include <boost/python/handle.hpp>

#include <boost/python/converter/registry.hpp>

#include <boost/python/converter/registered.hpp>

#include <boost/python/converter/builtin_converters.hpp>

#include <boost/python/converter/object_manager.hpp>

#include <boost/python/converter/shared_ptr_to_python.hpp>

#include <boost/python/detail/type_traits.hpp>

#include <boost/python/detail/value_is_shared_ptr.hpp>

#include <boost/python/detail/value_arg.hpp>

#include <boost/mpl/if.hpp>

#include <boost/mpl/or.hpp>

namespace boost { namespace python {

namespace detail

{

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES

template <bool is_const_ref>

struct object_manager_get_pytype

{

template <class U>

static PyTypeObject const* get( U& (*)() =0)

{

return converter::object_manager_traits::get_pytype();

}

};

template <>

struct object_manager_get_pytype<true>

{

template <class U>

static PyTypeObject const* get( U const& (*)() =0)

{

return converter::object_manager_traits::get_pytype();

}

};

#endif

template <class T>

struct object_manager_to_python_value

{

typedef typename value_arg<T>::type argument_type;

PyObject* operator()(argument_type) const;

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES

typedef boost::mpl::bool_<is_handle<T>::value> is_t_handle;

typedef boost::detail::indirect_traits::is_reference_to_const<T> is_t_const;

PyTypeObject const* get_pytype() const {

return get_pytype_aux((is_t_handle*)0);

}

inline static PyTypeObject const* get_pytype_aux(mpl::true_*) {return converter::object_manager_traits<T>::get_pytype();}

inline static PyTypeObject const* get_pytype_aux(mpl::false_* )

{

return object_manager_get_pytype<is_t_const::value>::get((T(*)())0);

}

#endif

// This information helps make_getter() decide whether to try to

// return an internal reference or not. I don't like it much,

// but it will have to serve for now.

BOOST_STATIC_CONSTANT(bool, uses_registry = false);

};

template <class T>

struct registry_to_python_value

{

typedef typename value_arg<T>::type argument_type;

PyObject* operator()(argument_type) const;

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES

PyTypeObject const* get_pytype() const {return converter::registered<T>::converters.to_python_target_type();}

#endif

// This information helps make_getter() decide whether to try to

// return an internal reference or not. I don't like it much,

// but it will have to serve for now.

BOOST_STATIC_CONSTANT(bool, uses_registry = true);

};

template <class T>

struct shared_ptr_to_python_value

{

typedef typename value_arg<T>::type argument_type;

PyObject* operator()(argument_type) const;

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES

PyTypeObject const* get_pytype() const {return get_pytype((boost::type<argument_type>*)0);}

#endif

// This information helps make_getter() decide whether to try to

// return an internal reference or not. I don't like it much,

// but it will have to serve for now.

BOOST_STATIC_CONSTANT(bool, uses_registry = false);

private:

#ifndef BOOST_PYTHON_NO_PY_SIGNATURES

template <class U>

PyTypeObject const* get_pytype(boost::type<shared_ptr &> *) const {return converter::registered::converters.to_python_target_type();}

template <class U>

PyTypeObject const* get_pytype(boost::type<const shared_ptr &> *) const {return converter::registered::converters.to_python_target_type();}

# if !defined(BOOST_NO_CXX11_SMART_PTR)

template <class U>

PyTypeObject const* get_pytype(boost::type<std::shared_ptr &> *) const {return converter::registered::converters.to_python_target_type();}

template <class U>

PyTypeObject const* get_pytype(boost::type<const std::shared_ptr &> *) const {return converter::registered::converters.to_python_target_type();}

# endif

#endif

};

}

template <class T>

struct to_python_value

: mpl::if_<

detail::value_is_shared_ptr<T>

, detail::shared_ptr_to_python_value<T>

, typename mpl::if_<

mpl::or_<

converter::is_object_manager<T>

, converter::is_reference_to_object_manager<T>

, detail::object_manager_to_python_value<T>

, detail::registry_to_python_value<T>

>::type

{

};

// implementation

namespace detail

{

template <class T>

inline PyObject* registry_to_python_value<T>::operator()(argument_type x) const

{

return converter::registered<argument_type>::converters.to_python(&x);

}

template <class T>

inline PyObject* object_manager_to_python_value<T>::operator()(argument_type x) const

{

return python::upcast<PyObject>(

python::xincref(

get_managed_object(x, tag))

);

}

template <class T>

inline PyObject* shared_ptr_to_python_value<T>::operator()(argument_type x) const

{

return converter::shared_ptr_to_python(x);

}

}} // namespace boost::python

#endif