UnitWrapper.h File Reference

Python wrapper for MIRA units. More...

#include <Python.h>
#include <python/BoostPythonWrapper.h>
#include <transform/Pose.h>
#include <fw/Unit.h>
#include <python/PythonSet.h>
#include <python/PythonException.h>
#include <python/PythonInterpreter.h>
#include <python/ReflectorWrapper.h>
#include <python/ScopedGIL.h>

Include dependency graph for UnitWrapper.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	PyUnit
class	PyUnitWrapperBase
class	PyUnitWrapper
class	PyUnitWrapper::BaseCallback
class	PyUnitWrapper::Callback< T >
class	PyUnitWrapper::CallbackInterval< T >
struct	ChannelAccessWrapper< T >
struct	ChannelWaitWrapper< T >
struct	ChannelReadWrapperBase< T >
struct	ChannelReadWrapper< T >
struct	ChannelReadIntervalWrapper< T >
	Also wrap ChannelReadInterval<T>::begin and ChannelReadInterval<T>::end to return the ChannelReadInterval<T>::IntervalList::const_iterator instead of the ChannelReadInterval<T>::const_iterator. More...

Namespaces
	mira
	mira::python

Macros
#define	MIRA_PYTHON_COMMA_HELPER   ,
#define	MIRA_PYTHONCONNECTOR_ALL_TYPES(MACRO)
#define	MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, TYPE, PREFIX)
#define	MIRA_PYTHONCONNECTOR_ALL_TYPES_2(MACRO)
#define	MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(type, name)
#define	MIRA_PYTHONCONNECTOR_TYPE_FOOTER(type)   MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(type,#type)
#define	MIRA_PYTHONCONNECTOR_PRIMITIVE_CHANNEL_WRAPPER(type, name)
#define	MIRA_PYTHONCONNECTOR_PRIMITIVE_VECTOR_CHANNEL_WRAPPER(type, name)
#define	MIRA_PYTHONCONNECTOR_PRIMITIVE_SET_CHANNEL_WRAPPER(type, name)
#define	MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER(type1, type2, name1, name2)
#define	MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER_STRING(type1, type2, name1, name2)
#define	MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER(type1, type2, name1, name2)
#define	MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER_STRING(type1, type2, name1, name2)

Functions
template<typename T >
Channel< T >	subscribe (PyUnitWrapper &unit, const std::string &channelID)
	Typed subscribe method every wrapped type must contain. More...
template<typename T >
Channel< T >	subscribeCb (PyUnitWrapper &unit, const std::string &channelID, boost::python::object callable)
	Typed subscribe method every wrapped type must contain. More...
template<typename T >
Channel< T >	subscribeIntervalCb (PyUnitWrapper &unit, const std::string &channelID, boost::python::object callable, const Duration &storageDuration)
	Typed subscribe method every wrapped type must contain. More...
template<typename T >
void	unsubscribe (PyUnitWrapper &unit, const std::string &channelID)
	Typed unsubscribe method every wrapped type must contain. More...
template<typename T >
Channel< T >	publish (PyUnitWrapper &unit, const std::string &channelID)
	Typed publish method every wrapped type must contain. More...
template<typename T >
boost::python::object	convertJSONtoObject (const json::Value &value)
	Create an object instance from JSON data MIRA's JSON deserialization capabilities. More...
template<typename T >
json::Value	convertObjectToJSON (const T &obj)
	Generate a JSON representation using MIRA's JSON serialization capabilities. More...

Detailed Description

Python wrapper for MIRA units.

Author

Tim Langner, Christian Vollmer, Tim van der Grinten

Date

2012/08/28

Macro Definition Documentation

MIRA_PYTHON_COMMA_HELPER

#define MIRA_PYTHON_COMMA_HELPER   ,

MIRA_PYTHONCONNECTOR_ALL_TYPES

#define MIRA_PYTHONCONNECTOR_ALL_TYPES

(

MACRO

)

Value:

MACRO(bool, "Bool");                            \
MACRO(int, "Int");                              \
MACRO(int64, "Int64");                          \
MACRO(float, "Float");                          \
MACRO(std::string, "String");

MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER

#define MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER	(		MACRO,
			TYPE,
			PREFIX
	)

Value:

MACRO(TYPE, bool, PREFIX, "Bool");          \
MACRO(TYPE, int, PREFIX, "Int");            \
MACRO(TYPE, int64, PREFIX, "Int64");        \
MACRO(TYPE, float, PREFIX, "Float");        \
MACRO##_STRING(TYPE, std::string, PREFIX, "String");

MIRA_PYTHONCONNECTOR_ALL_TYPES_2

#define MIRA_PYTHONCONNECTOR_ALL_TYPES_2

(

MACRO

)

Value:

MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, bool, "Bool");           \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, int, "Int");             \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, int64, "Int64");         \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, float, "Float");         \
MIRA_PYTHONCONNECTOR_ALL_TYPES_2_HELPER(MACRO, std::string, "String");

MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER

#define MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER	(		type,
			name
	)

MIRA_PYTHONCONNECTOR_TYPE_FOOTER

#define MIRA_PYTHONCONNECTOR_TYPE_FOOTER

(

type

)

MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(type,#type)

MIRA_PYTHONCONNECTOR_PRIMITIVE_CHANNEL_WRAPPER

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_CHANNEL_WRAPPER	(		type,
			name
	)

Value:

class_<mira::Channel<type> >("Channel" name)                                \
        .def("post", &mira::python::ChannelAccessWrapper<type>::postTimeFrame)  \
        .def("post", &mira::python::ChannelAccessWrapper<type>::postTime)       \
        .def("post", &mira::python::ChannelAccessWrapper<type>::post)           \
        .def("get", &mira::python::ChannelAccessWrapper<type>::get)             \
        .def("get", &mira::python::ChannelAccessWrapper<type>::getTime)         \
        .def("get", &mira::python::ChannelAccessWrapper<type>::getTimeDuration) \
        .def("read", &mira::python::ChannelAccessWrapper<type>::read)           \
        .def("read", &mira::python::ChannelAccessWrapper<type>::readTime)       \
        .def("read", &mira::python::ChannelAccessWrapper<type>::readTimeDuration)   \
        .def("hasPublisher", &Channel<type>::hasPublisher)                      \
        .def("hasSubscriber", &Channel<type>::hasSubscriber)                    \
        .def("isValid", &Channel<type>::isValid)                                \
        .def("waitForPublisher", &mira::python::ChannelWaitWrapper<type>::waitForPublisherTime) \
        .def("waitForPublisher", &mira::python::ChannelWaitWrapper<type>::waitForPublisher) \
        .def("waitForData", &mira::python::ChannelWaitWrapper<type>::waitForDataTime)   \
        .def("waitForData", &mira::python::ChannelWaitWrapper<type>::waitForData)   \
    ;                                                                           \
    class_<mira::ChannelRead<type> >((std::string("ChannelRead")+name).c_str())\
        .add_property("Value", make_function(&mira::python::ChannelReadWrapper<type>::getValue,     \
             return_value_policy<return_by_value>()))                   \
        .add_property("Timestamp", &mira::python::ChannelReadWrapper<type>::getTimestamp)   \
        .add_property("FrameID", &mira::python::ChannelReadWrapper<type>::getFrameID)       \
        .add_property("SequenceID", &mira::python::ChannelReadWrapper<type>::getSequenceID) \
    ;                                                                           \
    class_<mira::ChannelReadInterval<type> >((std::string("ChannelReadInterval")+name).c_str())\
        .def("__len__", &mira::ChannelReadInterval<type>::size) \
        .def("__iter__", range<return_value_policy<return_by_value> >(&mira::python::ChannelReadIntervalWrapper<type>::begin, &mira::python::ChannelReadIntervalWrapper<type>::end)) \
    ;

MIRA_PYTHONCONNECTOR_PRIMITIVE_VECTOR_CHANNEL_WRAPPER

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_VECTOR_CHANNEL_WRAPPER	(		type,
			name
	)

Value:

class_<std::vector<type> >("Vector" name)                                                       \
        .def(vector_indexing_suite<std::vector<type> >())                                           \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::vector<type>, "Vector" name)

MIRA_PYTHONCONNECTOR_PRIMITIVE_SET_CHANNEL_WRAPPER

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_SET_CHANNEL_WRAPPER	(		type,
			name
	)

Value:

MIRA_PYTHONCONNECTOR_PYTHONSET_FUNCTIONS(type, "Set" name,                                      \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::set<type>, "Set" name))

MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER	(		type1,
			type2,
			name1,
			name2
	)

Value:

class_<std::map<type1, type2> >("Map" name1 name2)                                              \
        .def(map_indexing_suite<std::map<type1, type2> >())                                         \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER type2>, "Map" name1 name2)

MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER_STRING

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_CHANNEL_WRAPPER_STRING	(		type1,
			type2,
			name1,
			name2
	)

Value:

class_<std::map<type1, type2> >("Map" name1 name2)                                              \
        .def(map_indexing_suite<std::map<type1, type2>, true>())                                    \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER type2>, "Map" name1 name2)

MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER	(		type1,
			type2,
			name1,
			name2
	)

Value:

class_<std::map<type1, std::vector<type2> > >("Map" name1 "Vector" name2)                       \
        .def(map_indexing_suite<std::map<type1, std::vector<type2> > >())                           \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER std::vector<type2> >, "Map" name1 "Vector" name2)

MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER_STRING

#define MIRA_PYTHONCONNECTOR_PRIMITIVE_MAP_OF_VECTORS_CHANNEL_WRAPPER_STRING	(		type1,
			type2,
			name1,
			name2
	)

Value:

class_<std::map<type1, std::vector<type2> > >("Map" name1 "Vector" name2)                               \
        .def(map_indexing_suite<std::map<type1, std::vector<type2> >, true>())                              \
        MIRA_PYTHONCONNECTOR_NAMED_TYPE_FOOTER(std::map<type1 MIRA_PYTHON_COMMA_HELPER std::vector<type2> >, "Map" name1 "Vector" name2)