Belle2::PyObjConvUtils Namespace Reference

Python object converter utilities namespace. More...

Classes
class	convertToPythonObjectVisitor
	Helper function object to unpack a value from a variant to a python object. More...
struct	SizeT
	Helper construct for TMP that provides an index at compile time to recurse through type lists. More...
struct	Type
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< bool >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< boost::variant< Types... > >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< double >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< float >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< int >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< std::map< A, B > >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< std::optional< T > >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< std::set< T > >
	Convert a templeate argument into a string for corresponding Python type. More...
struct	Type< std::shared_ptr< Path > >
	Some modules take a path as argument so let's add this as well. More...
struct	Type< std::string >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< std::tuple< Types... > >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< std::vector< T > >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< unsigned int >
	Converts a template argument into a string for corresponding Python type. More...
struct	Type< unsigned long int >
	Converts a template argument into a string for corresponding Python type. More...
struct	VariadicType
	Recursively convert multiple types to type names (used for tuples). More...
struct	VariadicType< T >
	Recursively convert multiple types to type names (used for tuples). More...

Functions
bool	checkPythonObject (const boost::python::object &pyObject, bool)
	check if the python object can be converted to the given type.
bool	checkPythonObject (const boost::python::object &pyObject, float)
	check if the python object can be converted to the given type.
bool	checkPythonObject (const boost::python::object &pyObject, double)
	check if the python object can be converted to the given type.
bool	checkPythonObject (const boost::python::object &pyObject, int)
	check if the python object can be converted to the given an integral number
bool	checkPythonObject (const boost::python::object &pyObject, unsigned int)
	check if the python object can be converted to the given an integral number
bool	checkPythonObject (const boost::python::object &pyObject, unsigned long int)
	check if the python object can be converted to the given an integral number
bool	checkPythonObject (const boost::python::object &pyObject, const std::string &)
	check if the python object can be converted to the given a string
template<typename Key, typename Value>
bool	checkPythonObject (const boost::python::object &pyObject, const std::map< Key, Value > &)
	Check if the python object is a mapping of the correct key and value types.
template<typename Value>
bool	checkPythonObject (const boost::python::object &pyObject, const std::vector< Value > &)
	check if the python object can be converted to the given std::vector type
template<typename Value>
bool	checkPythonObject (const boost::python::object &pyObject, const std::set< Value > &)
	check if the python object can be converted to the given std::set type
template<typename... Types>
bool	checkPythonObject (const boost::python::object &pyObject, const std::tuple< Types... > &)
	check if the python object can be converted to the given std::tuple type
template<typename... Types>
bool	checkPythonObject (const boost::python::object &pyObject, const boost::variant< Types... > &)
	check if the python object can be converted to the given boost::variant type
template<typename Type>
bool	checkPythonObject (const boost::python::object &pyObject, const std::optional< Type > &)
	check if the python object can be converted to the given std::optional<T> type
template<typename Scalar>
Scalar	convertPythonObject (const boost::python::object &pyObject, Scalar)
	Convert from Python to given type.
template<typename T>
std::shared_ptr< T >	convertPythonObject (const boost::python::object &pyObject, const std::shared_ptr< T > &)
	Convert from Python to given type.
template<typename Key, typename Value>
std::map< Key, Value >	convertPythonObject (const boost::python::object &pyObject, const std::map< Key, Value > &)
	Convert from Python to given type.
template<typename Value>
std::vector< Value >	convertPythonObject (const boost::python::object &pyObject, const std::vector< Value > &)
	Convert from Python to given type.
template<typename Value>
std::set< Value >	convertPythonObject (const boost::python::object &pyObject, const std::set< Value > &)
	Convert from Python to given type.
template<typename... Types>
std::tuple< Types... >	convertPythonObject (const boost::python::object &pyObject, const std::tuple< Types... > &)
	Convert from Python to given type.
template<typename... Types>
boost::variant< Types... >	convertPythonObject (const boost::python::object &pyObject, const boost::variant< Types... > &)
	Convert from Python to given type.
template<typename Type>
std::optional< Type >	convertPythonObject (const boost::python::object &pyObject, const std::optional< Type > &)
	Convert from Python to the given std::optional type.
template<typename Scalar>
boost::python::object	convertToPythonObject (const Scalar &value)
	------------— From C++ TO Python Converter ---------------------—
template<typename Value>
boost::python::list	convertToPythonObject (const std::vector< Value > &vector)
	Writes content of a std::vector to a python list.
template<typename Value>
boost::python::object	convertToPythonObject (const std::set< Value > &set)
	Convert std::set to a python object.
template<typename Key, typename Value>
boost::python::dict	convertToPythonObject (const std::map< Key, Value > &map)
	Writes content of a std::map to a python dict.
template<typename... Types>
boost::python::tuple	convertToPythonObject (const std::tuple< Types... > &tuple)
	Writes content of a std::tuple to a python tuple.
template<typename... Types>
boost::python::object	convertToPythonObject (const boost::variant< Types... > &variant)
	Writes content of a boost::variant to a python object.
template<typename Type>
boost::python::object	convertToPythonObject (const std::optional< Type > &optional)
	Convert from the given std::optional type to Python.
template<class Functor>
bool	iteratePythonObject (const boost::python::object &pyObject, Functor function)
	Helper function to loop over a python object that implements the iterator concept and call a functor with each element as argument.
template<typename... Types, std::size_t ... Is>
bool	CheckTuple (const std::tuple< Types... > &tuple, const boost::python::tuple &pyTuple, std::index_sequence< Is... >)
	Check if all tuple elements match.
template<typename VariantType>
bool	CheckVariant (const VariantType &, const boost::python::object &, SizeT< 0 >)
	Recursion sentinel for the case that all former type checks failed for the variant.
template<typename... Types, size_t N>
bool	CheckVariant (const boost::variant< Types... > &variant, const boost::python::object &pyObject, SizeT< N >)
	Recursion through the variant types checking the python object for the type at position N - 1.
template<typename... Types>
bool	checkPythonObject (const boost::python::object &pyObject, const boost::variant< Types... > variant)
	Check if the python object is a tuple of objects of the correct types.
template<typename TupleType>
void	GetTuple (const TupleType &tuple, boost::python::list &pyList)
	TMP (Template Meta Programming ) The given python list is filled, and later converted into a python tuple (in convertToPythonObject).
template<typename TupleType>
void	GetTuple (const TupleType &, boost::python::list &, SizeT< 0 >)
	Break recursion when all members are already appended to the list.
template<typename TupleType, size_t N>
void	GetTuple (const TupleType &tuple, boost::python::list &pyList, SizeT< N >)
	Append elements of the tuple to pyList by recursively calling this function with the element index as argument type.
template<typename TupleType>
void	SetTuple (TupleType &tuple, const boost::python::tuple &pyTuple)
	TMP (Template Meta Programming ) The given python tuple is written into the given c++ tuple.
template<typename TupleType>
void	SetTuple (TupleType &, const boost::python::tuple &, SizeT< 0 >)
	Break recursion once all elements have been set.
template<typename TupleType, size_t N>
void	SetTuple (TupleType &tuple, const boost::python::tuple &pyTuple, SizeT< N >)
	Set the elements of the tuple recursively by calling with the function with the next tuple index and converting one element.
template<typename... Types>
void	SetVariant (boost::variant< Types... > &, const boost::python::object &pyObject, SizeT< 0 >)
	TMP (Template Meta Programming ) The given python object is written into the given c++ boost variant.
template<typename... Types, size_t N>
void	SetVariant (boost::variant< Types... > &variant, const boost::python::object &pyObject, SizeT< N >)
	Recursively go through all possible types of the variant and check which one is a possible conversion.

Detailed Description

Python object converter utilities namespace.

Provides templates for converting python objects to c++ objects and the other way round.

This is done by using the type of the value provided by the module as a template parameter. Hence the compiler can infer which converter should be used. Note: We are only interested in the type of the value, the actual value isn't used at all!

Function Documentation

checkPythonObject() [1/13]

bool checkPythonObject ( const boost::python::object & pyObject, bool  )

inline

check if the python object can be converted to the given type.

------------— Check python objects for exact type match ---------------------—

Check if the python object is a boolean

Definition at line 203 of file PyObjConvUtils.h.

    {
      return PyBool_Check(pyObject.ptr());
    }

checkPythonObject() [2/13]

template<typename... Types>

bool checkPythonObject	(	const boost::python::object &	pyObject,
		const boost::variant< Types... >	variant )

Check if the python object is a tuple of objects of the correct types.

Definition at line 338 of file PyObjConvUtils.h.

    {
      return CheckVariant(variant, pyObject, SizeT<sizeof...(Types)>());
    }

checkPythonObject() [3/13]

template<typename Key, typename Value>

bool checkPythonObject	(	const boost::python::object &	pyObject,
		const std::map< Key, Value > &	)

Check if the python object is a mapping of the correct key and value types.

Definition at line 245 of file PyObjConvUtils.h.

    {
      if (not PyDict_Check(pyObject.ptr())) return false;
      const boost::python::dict& pyDict = static_cast<const boost::python::dict&>(pyObject);
      boost::python::list keys = pyDict.keys();
      boost::python::list values = pyDict.values();
      for (int i = 0; i < boost::python::len(keys); ++i) {
        if (not checkPythonObject(keys[i], Key())) return false;
        if (not checkPythonObject(values[i], Value())) return false;
      }
      return true;
    }

checkPythonObject() [4/13]

template<typename Type>

bool checkPythonObject	(	const boost::python::object &	pyObject,
		const std::optional< Type > &	)

check if the python object can be converted to the given std::optional<T> type

Check if a python object can be converted to std::optional.

Returns

true if pyObject is None or convertible to the type of the std::optional

Definition at line 347 of file PyObjConvUtils.h.

    {
      return pyObject.is_none() or checkPythonObject(pyObject, Type());
    }

checkPythonObject() [5/13]

template<typename Value>

bool checkPythonObject	(	const boost::python::object &	pyObject,
		const std::set< Value > &	)

check if the python object can be converted to the given std::set type

Definition at line 289 of file PyObjConvUtils.h.

    {
      if (not PyAnySet_Check(pyObject.ptr())) return false;
      return iteratePythonObject(pyObject, [](const boost::python::object & element) {
        return checkPythonObject(element, Value());
      });
    }

checkPythonObject() [6/13]

bool checkPythonObject ( const boost::python::object & pyObject, const std::string &  )

inline

check if the python object can be converted to the given a string

Check if the python object is a string.

Definition at line 238 of file PyObjConvUtils.h.

    {
      return PyUnicode_Check(pyObject.ptr());
    }

checkPythonObject() [7/13]

template<typename... Types>

bool checkPythonObject	(	const boost::python::object &	pyObject,
		const std::tuple< Types... > &	tuple )

check if the python object can be converted to the given std::tuple type

Check if the python object is a tuple of objects of the correct types.

Definition at line 307 of file PyObjConvUtils.h.

    {
      if (not PyTuple_Check(pyObject.ptr())) return false;
      const boost::python::tuple& pyTuple = static_cast<const boost::python::tuple&>(pyObject);
      return CheckTuple(tuple, pyTuple, std::index_sequence_for<Types ...>());
    }

checkPythonObject() [8/13]

template<typename Value>

bool checkPythonObject	(	const boost::python::object &	pyObject,
		const std::vector< Value > &	)

check if the python object can be converted to the given std::vector type

Check if the python object is a list of objects of the correct value type.

Definition at line 280 of file PyObjConvUtils.h.

    {
      if (not PyList_Check(pyObject.ptr())) return false;
      return iteratePythonObject(pyObject, [](const boost::python::object & element) {
        return checkPythonObject(element, Value());
      });
    }

checkPythonObject() [9/13]

bool checkPythonObject ( const boost::python::object & pyObject, double  )

inline

check if the python object can be converted to the given type.

Check if the python object is a float number.

Definition at line 232 of file PyObjConvUtils.h.

    {
      return PyFloat_CheckExact(pyObject.ptr());
    }

checkPythonObject() [10/13]

bool checkPythonObject ( const boost::python::object & pyObject, float  )

inline

check if the python object can be converted to the given type.

Check if the python object is a float number.

Definition at line 226 of file PyObjConvUtils.h.

    {
      return PyFloat_CheckExact(pyObject.ptr());
    }

checkPythonObject() [11/13]

bool checkPythonObject ( const boost::python::object & pyObject, int  )

inline

check if the python object can be converted to the given an integral number

Check if the python object is an integral number.

Definition at line 209 of file PyObjConvUtils.h.

    {
      return PyLong_CheckExact(pyObject.ptr());
    }

checkPythonObject() [12/13]

bool checkPythonObject ( const boost::python::object & pyObject, unsigned int  )

inline

check if the python object can be converted to the given an integral number

Check if the python object is an integral number.

Definition at line 214 of file PyObjConvUtils.h.

    {
      return PyLong_CheckExact(pyObject.ptr());
    }

checkPythonObject() [13/13]

bool checkPythonObject ( const boost::python::object & pyObject, unsigned long int  )

inline

check if the python object can be converted to the given an integral number

Check if the python object is an integral number.

Definition at line 220 of file PyObjConvUtils.h.

    {
      return PyLong_CheckExact(pyObject.ptr());
    }

CheckTuple()

template<typename... Types, std::size_t ... Is>

bool CheckTuple	(	const std::tuple< Types... > &	tuple,
		const boost::python::tuple &	pyTuple,
		std::index_sequence< Is... >	)

Check if all tuple elements match.

Definition at line 299 of file PyObjConvUtils.h.

    {
      return (... && checkPythonObject(pyTuple[Is], std::get<Is>(tuple)));
    }

CheckVariant() [1/2]

template<typename... Types, size_t N>

bool CheckVariant	(	const boost::variant< Types... > &	variant,
		const boost::python::object &	pyObject,
		SizeT< N >	)

Recursion through the variant types checking the python object for the type at position N - 1.

Definition at line 325 of file PyObjConvUtils.h.

    {
      using Scalar = typename std::tuple_element < N - 1, std::tuple<Types...> >::type;
      if (checkPythonObject(pyObject, Scalar())) {
        return true;
      }
      return CheckVariant(variant, pyObject, SizeT < N - 1 > ());
    }

CheckVariant() [2/2]

template<typename VariantType>

bool CheckVariant	(	const VariantType &	,
		const boost::python::object &	,
		SizeT< 0 >	)

Recursion sentinel for the case that all former type checks failed for the variant.

Definition at line 316 of file PyObjConvUtils.h.

    {
      return false;
    }

convertPythonObject() [1/8]

template<typename... Types>

boost::variant< Types... > convertPythonObject	(	const boost::python::object &	pyObject,
		const boost::variant< Types... > &	)

Convert from Python to given type.

Reads boost::variant from a python object.

Parameters

pyObject

Python object which stores the value.

Returns

boost::variant<Types...>, which holds the value from the python object

Definition at line 704 of file PyObjConvUtils.h.

    {
      boost::variant<Types...> tmpVariant;
      SetVariant(tmpVariant, pyObject, SizeT<sizeof...(Types)>());
      return tmpVariant;
    }

convertPythonObject() [2/8]

template<typename Key, typename Value>

std::map< Key, Value > convertPythonObject	(	const boost::python::object &	pyObject,
		const std::map< Key, Value > &	)

Convert from Python to given type.

Reads std::map from a python object.

Parameters

pyObject

Python object which stores the map.

Returns

Map, which holds the map from the python object

Definition at line 599 of file PyObjConvUtils.h.

    {
      std::map<Key, Value> tmpMap;
      const boost::python::dict& pyDict = static_cast<const boost::python::dict&>(pyObject);
      boost::python::list keys = pyDict.keys();
 
      for (int i = 0; i < boost::python::len(keys); ++i) {
        Key key = convertPythonObject(keys[boost::python::object(i)], Key());
        Value value = convertPythonObject(pyDict[key], Value());
        tmpMap.insert(std::pair<Key, Value>(key, value));
      }
      return tmpMap;
    }

convertPythonObject() [3/8]

template<typename Type>

std::optional< Type > convertPythonObject	(	const boost::python::object &	pyObject,
		const std::optional< Type > &	)

Convert from Python to the given std::optional type.

Convert a python object to std::optional.

Returns

std::optional which is not set if pyObject is None. Otherwise it will be converted to the type of the boost optional

Definition at line 718 of file PyObjConvUtils.h.

    {
      std::optional<Type> tmpOptional = std::nullopt;
      if (!pyObject.is_none()) {
        tmpOptional = convertPythonObject(pyObject, Type());
      }
      return tmpOptional;
    }

convertPythonObject() [4/8]

template<typename Value>

std::set< Value > convertPythonObject	(	const boost::python::object &	pyObject,
		const std::set< Value > &	)

Convert from Python to given type.

Convert a python set to a std::set.

Definition at line 577 of file PyObjConvUtils.h.

    {
      std::set<Value> result;
      if (PyAnySet_Check(pyObject.ptr())) {
        iteratePythonObject(pyObject, [&result](const boost::python::object & element) {
          result.emplace(convertPythonObject(element, Value()));
          return true;
        });
      } else {
        result.emplace(convertPythonObject(pyObject, Value()));
      }
      return result;
    }

convertPythonObject() [5/8]

template<typename T>

std::shared_ptr< T > convertPythonObject	(	const boost::python::object &	pyObject,
		const std::shared_ptr< T > &	)

Convert from Python to given type.

Reads a std::shared_ptr<T> from a python object.

Parameters

pyObject	Python object which stores the shared pointer.
std::shared_ptr<T>	A shared pointer.

Returns

std::shared_ptr<T>, which holds the value from the python object.

Definition at line 535 of file PyObjConvUtils.h.

    {
 
      std::shared_ptr<T> tmpValue;
      boost::python::extract<std::shared_ptr<T>> valueProxy(pyObject);
      if (valueProxy.check()) {
        tmpValue = valueProxy();
      } else {
        throw std::runtime_error(
          std::string("Could not convert value: Expected type '") + Type<std::shared_ptr<T>>::name() + "' instead of '" +
          pyObject.ptr()->ob_type->tp_name + "'."
        );
      }
      return tmpValue;
 
    }

convertPythonObject() [6/8]

template<typename... Types>

std::tuple< Types... > convertPythonObject	(	const boost::python::object &	pyObject,
		const std::tuple< Types... > &	)

Convert from Python to given type.

Reads std::tuple from a python object.

Parameters

pyObject

Python object which stores the map.

Returns

std::tuple<Types...>, which holds the map from the python object

Definition at line 655 of file PyObjConvUtils.h.

    {
      std::tuple<Types...> tmpTuple;
      const boost::python::tuple& pyTuple = static_cast<const boost::python::tuple&>(pyObject);
      SetTuple(tmpTuple, pyTuple);
      return tmpTuple;
    }

convertPythonObject() [7/8]

template<typename Value>

std::vector< Value > convertPythonObject	(	const boost::python::object &	pyObject,
		const std::vector< Value > &	)

Convert from Python to given type.

Reads std::vector from a python object.

If the python object isn't a list, a std::vector with the given object as single entry is returned.

Parameters

pyObject

Python object which stores the vector.

Returns

Vector, which holds the vector from the python object

Definition at line 560 of file PyObjConvUtils.h.

    {
 
      std::vector<Value> tmpVector;
      if (PyList_Check(pyObject.ptr()) or PyGen_Check(pyObject.ptr())) {
        iteratePythonObject(pyObject, [&tmpVector](const boost::python::object & element) {
          tmpVector.emplace_back(convertPythonObject(element, Value()));
          return true;
        });
      } else {
        tmpVector.emplace_back(convertPythonObject(pyObject, Value()));
      }
      return tmpVector;
    }

convertPythonObject() [8/8]

template<typename Scalar>

Scalar convertPythonObject	(	const boost::python::object &	pyObject,
		const Scalar	)

Convert from Python to given type.

------------— From Python TO C++ Converter ---------------------—

Reads a scalar type (int, double, string, bool) from a python object.

Parameters

pyObject	Python object which stores the scalar type.
Scalar	A scalar.

Returns

Scalar type, which holds the value from the python object

Definition at line 511 of file PyObjConvUtils.h.

    {
 
      Scalar tmpValue;
      boost::python::extract<Scalar> valueProxy(pyObject);
      if (valueProxy.check()) {
        tmpValue = static_cast<Scalar>(valueProxy);
      } else {
        throw std::runtime_error(std::string("Could not convert value: Expected type '") + Type<Scalar>::name() + "' instead of '" +
                                 pyObject.ptr()->ob_type->tp_name + "'.");
      }
      return tmpValue;
 
    }

convertToPythonObject() [1/7]

template<typename... Types>

boost::python::object convertToPythonObject

(

const boost::variant< Types... > &

variant

)

Writes content of a boost::variant to a python object.

Parameters

variant

The variant whose content should be stored in a python object.

Returns

The python object where the the content of the map is stored.

Definition at line 477 of file PyObjConvUtils.h.

    {
      return boost::apply_visitor(convertToPythonObjectVisitor(), variant);
    }

convertToPythonObject() [2/7]

template<typename Scalar>

boost::python::object convertToPythonObject

(

const Scalar &

value

)

------------— From C++ TO Python Converter ---------------------—

Writes a scalar type (int, double, string, bool) to a python object.

Parameters

value

The scalar who should be converted to a python object.

Returns

python object where the scalar is stored.

Definition at line 363 of file PyObjConvUtils.h.

    {
      return boost::python::object(value);
    }

convertToPythonObject() [3/7]

template<typename Key, typename Value>

boost::python::dict convertToPythonObject

(

const std::map< Key, Value > &

map

)

Writes content of a std::map to a python dict.

Parameters

map	The map whose items should be stored to a python dict.

Returns

dict The python dict where the the content of the map is stored.

Definition at line 405 of file PyObjConvUtils.h.

    {
      boost::python::dict outputDict;
      for (auto pair : map) {
        outputDict[convertToPythonObject(pair.first)] = convertToPythonObject(pair.second);
      }
      return outputDict;
    }

convertToPythonObject() [4/7]

template<typename Type>

boost::python::object convertToPythonObject

(

const std::optional< Type > &

optional

)

Convert from the given std::optional type to Python.

Convert a std::optional to python.

Parameters

optional

the optional object to convert

Returns

If the optional is not set return None, otherwise just return the converted type it contains.

Definition at line 490 of file PyObjConvUtils.h.

    {
      if (optional) {
        return convertToPythonObject(*optional);
      } else {
        return boost::python::object();
      }
    }

convertToPythonObject() [5/7]

template<typename Value>

boost::python::object convertToPythonObject

(

const std::set< Value > &

set

)

Convert std::set to a python object.

Write the content of a std::set to a python set.

Parameters

set	the set that should be converted

Returns

python object for the set

Definition at line 389 of file PyObjConvUtils.h.

    {
      boost::python::object result(boost::python::handle<>(PySet_New(nullptr)));
      for (const auto& value : set) {
        PySet_Add(result.ptr(), convertToPythonObject(value).ptr());
      }
      return result;
    }

convertToPythonObject() [6/7]

template<typename... Types>

boost::python::tuple convertToPythonObject

(

const std::tuple< Types... > &

tuple

)

Writes content of a std::tuple to a python tuple.

Parameters

tuple

The tuple whose items should be stored to a python tuple.

Returns

The python tuple where the content of the map is stored.

Definition at line 449 of file PyObjConvUtils.h.

    {
      boost::python::list outputList;
      GetTuple(tuple, outputList);
      boost::python::tuple outputTuple(outputList);
      return outputTuple;
    }

convertToPythonObject() [7/7]

template<typename Value>

boost::python::list convertToPythonObject

(

const std::vector< Value > &

vector

)

Writes content of a std::vector to a python list.

Parameters

vector

The vector whose items should be stored to a python list.

Returns

object python list where the vector is stored.

Definition at line 375 of file PyObjConvUtils.h.

    {
      boost::python::list outputList;
      for (const auto& value : vector) {
        outputList.append(convertToPythonObject(value));
      }
      return outputList;
    }

GetTuple() [1/3]

template<typename TupleType>

void GetTuple ( const TupleType & , boost::python::list & , SizeT< 0 >  )

inline

Break recursion when all members are already appended to the list.

Definition at line 430 of file PyObjConvUtils.h.

{ }

GetTuple() [2/3]

template<typename TupleType>

void GetTuple ( const TupleType & tuple, boost::python::list & pyList )

inline

TMP (Template Meta Programming ) The given python list is filled, and later converted into a python tuple (in convertToPythonObject).

To fill the python list from the C++ std::tuple we need again TMP methods. The variadic template std::tuple is copied by the recursive defined template function GetTuple, the overloaded argument (type SizeT<>) of the function serves as a counter for the recursion depth.

Definition at line 423 of file PyObjConvUtils.h.

    {
      GetTuple(tuple, pyList, SizeT<std::tuple_size<TupleType>::value>());
    }

GetTuple() [3/3]

template<typename TupleType, size_t N>

void GetTuple ( const TupleType & tuple, boost::python::list & pyList, SizeT< N >  )

inline

Append elements of the tuple to pyList by recursively calling this function with the element index as argument type.

Definition at line 435 of file PyObjConvUtils.h.

    {
      GetTuple(tuple, pyList, SizeT < N - 1 > ());
      pyList.append(convertToPythonObject(std::get < N - 1 > (tuple)));
    }

iteratePythonObject()

template<class Functor>

bool iteratePythonObject	(	const boost::python::object &	pyObject,
		Functor	function )

Helper function to loop over a python object that implements the iterator concept and call a functor with each element as argument.

Parameters

pyObject	the python object to iterate over
function	any functor object which accepts a boost::python::object as its only argument and returns true if the iteration should be continued

Returns

true if the iteration was completed over all elements

Definition at line 266 of file PyObjConvUtils.h.

    {
      boost::python::object iterator(boost::python::handle<>(PyObject_GetIter(pyObject.ptr())));
      PyObject* item{nullptr};
      // ok, loop over the iterator and check all elements
      while ((item = PyIter_Next(iterator.ptr()))) {
        boost::python::object obj{boost::python::handle<>(item)}; // to make sure we properly decref
        if (not function(obj)) return false;
      }
      return true;
    }

SetTuple() [1/3]

template<typename TupleType>

void SetTuple ( TupleType & , const boost::python::tuple & , SizeT< 0 >  )

inline

Break recursion once all elements have been set.

Definition at line 636 of file PyObjConvUtils.h.

{ }

SetTuple() [2/3]

template<typename TupleType>

void SetTuple ( TupleType & tuple, const boost::python::tuple & pyTuple )

inline

TMP (Template Meta Programming ) The given python tuple is written into the given c++ tuple.

To fill the C++ std::tuple we need again TMP methods. The variadic template std::tuple is filled by the recursive defined template function SetTuple, the overloaded argument (type SizeT<>) of the function serves as a counter for the recursion depth.

Definition at line 623 of file PyObjConvUtils.h.

    {
      static const unsigned N = std::tuple_size<TupleType>::value;
      if ((unsigned)boost::python::len(pyTuple) != N) {
        throw std::runtime_error(std::string("Given python tuple has length ") +
                                 std::to_string(boost::python::len(pyTuple)) +
                                 ", expected " + std::to_string(N));
      }
      SetTuple(tuple, pyTuple, SizeT<N>());
    }

SetTuple() [3/3]

template<typename TupleType, size_t N>

void SetTuple ( TupleType & tuple, const boost::python::tuple & pyTuple, SizeT< N >  )

inline

Set the elements of the tuple recursively by calling with the function with the next tuple index and converting one element.

Definition at line 641 of file PyObjConvUtils.h.

    {
      SetTuple(tuple, pyTuple, SizeT < N - 1 > ());
      std::get < N - 1 > (tuple) = convertPythonObject(pyTuple[N - 1], std::get < N - 1 > (tuple));
    }

SetVariant() [1/2]

template<typename... Types>

void SetVariant ( boost::variant< Types... > & , const boost::python::object & pyObject, SizeT< 0 >  )

inline

TMP (Template Meta Programming ) The given python object is written into the given c++ boost variant.

To fill the C++ boost::variant we need again TMP methods. The variadic template boost::variant is filled by the recursive defined template function SetVariant, the overloaded argument (type SizeT<>) of the function serves as a counter for the recursion depth.

Definition at line 672 of file PyObjConvUtils.h.

    {
      throw std::runtime_error(std::string("Could not set module parameter: Expected type '") +
                               Type<boost::variant<Types...> >::name() + "' instead of '" +
                               pyObject.ptr()->ob_type->tp_name + "'.");
    }

SetVariant() [2/2]

template<typename... Types, size_t N>

void SetVariant ( boost::variant< Types... > & variant, const boost::python::object & pyObject, SizeT< N >  )

inline

Recursively go through all possible types of the variant and check which one is a possible conversion.

Definition at line 681 of file PyObjConvUtils.h.

    {
      using Scalar = typename std::tuple_element < N - 1, std::tuple<Types...> >::type;
      if (checkPythonObject(pyObject, Scalar())) {
        try {
          Scalar value = convertPythonObject(pyObject, Scalar());
          variant = value;
          return;
        } catch (const std::runtime_error& e) {
        }
      }
      // Conversion failed - try next type
      SetVariant(variant, pyObject, SizeT < N - 1 > ());
    }