Orocos Real-Time Toolkit  2.5.0
Classes | Functions
RTT::types Namespace Reference

Classes for typekits for describing and handling user data types. More...

Classes

struct  BoolTypeInfo
 Write boolean as 'true' or 'false'. More...
class  RealTimeTypekitPlugin
 This interface defines the types of the realTime package. More...
struct  EmptySendHandle
 This is a placeholder for scripting purposes. More...
struct  RTStringTypeInfo
 Standard string specialisation that removes decomposition. More...
struct  StdPrimitiveTypeInfo
 Type information for standard C types or structs of which no introspection is required and NOT used on data ports. More...
struct  StdStringTypeInfo
 Standard string specialisation that removes decomposition. More...
struct  StdTypeInfo
 Type information for standard C types or structs of which no introspection is required. More...
struct  StdVectorTypeInfo
 This class tells Orocos how to handle std::vector<double>. More...
class  BoostArrayTypeInfo
 Template for data types that are of type boost::array<U,int>. More...
class  carray
 Wraps a C array such that we can return a C array from a DataSource. More...
class  CArrayTypeInfo
 Template for data types that are C-style arrays. More...
struct  EnumTypeInfo
 Type information for Enum types for which they are convertible to int. More...
class  GlobalsRepository
 An RTT::ConfigurationInterface for holding global variables. More...
class  UnaryOp
 UnaryOperator contains information on some unary operator that operates on one arg of a certain type. More...
class  OperatorRepository
 This class builds on upon construction all expression operators known to Orocos. More...
class  UnaryOperator
 An operator which reads a single internal::DataSource and returns a modified result. More...
class  BinaryOperator
 An operator which reads a two DataSources and returns a modified result. More...
class  PrimitiveSequenceTypeInfo
 New-style SequenceTypeInfo which offers type info for sequences which can NOT be sent over flow ports. More...
class  PrimitiveTypeInfo
 This template class allows primitive types, which are not sent over ports, to be added to Orocos. More...
struct  sequence_ctor
 Sequence constructor which takes the number of elements in the sequence. More...
struct  sequence_varargs_ctor
 See NArityDataSource which requires a function object like this one. More...
struct  sequence_constructor_datasource
 Helper DataSource for constructing sequences with a variable number of parameters. More...
struct  SequenceBuilder
 Constructs an sequence with n elements, which are given upon construction time. More...
struct  sequence_ctor2
 Constructs a sequence from the number of elements and a prototype element for these elements. More...
class  SequenceTypeInfo
 Old-style SequenceTypeInfo which offers type info for sequences which can be sent over flow ports. More...
class  SequenceTypeInfoBase
 Template for data types that are C++ STL Sequences with operator[], size() and capacity() methods. More...
class  StructTypeInfo
 Type Information for data types that are structs, ie all user data types fall in this category. More...
struct  TemplateConstructor
 The constructor classes allow to define type constructors or type conversions (convert type B from type A). More...
class  TemplateTypeInfo
 This template class allows user types to be used in all Orocos primitives. More...
class  TransportPlugin
 A class which registers TypeTransporter instances to types. More...
class  type_discovery
 This archive is capable of decomposing objects of serialization level 1 and 2 into part data sources. More...
struct  TypeBuilder
 This interface describes how constructors work. More...
class  TypeInfo
 A class for representing a user type, and which can build instances of that type. More...
class  EmptyTypeInfo
 Empty implementation of TypeInfo interface. More...
struct  TypeInfoName
 This helper class allows only type names to be added to Orocos. More...
class  TypeInfoRepository
 This class contains all known types to Orocos. More...
class  TypekitPlugin
 This interface defines how additional typekits are loaded into Orocos. More...
class  TypekitRepository
 This class allows the RTT to be extended with additional typekits (TypekitPlugin), such as for kinematics or any library foreign to Orocos. More...
class  TypeMarshaller
 Objects implementing this interface have the capability to convert data sources to and from a binary representation. More...
class  TypeTransporter
 This interface defines the function a transport protocol must support in order to allow Orocos components to remotely communicate one data type. More...
struct  stdvector_varargs_ctor
 See internal::NArityDataSource which requires a function object like this one. More...
struct  StdVectorBuilder
 Constructs an array with n elements, which are given upon construction time. More...

Functions

void loadStdTypes (TypeInfoRepository::shared_ptr ti)
void loadOrocosTypes (TypeInfoRepository::shared_ptr ti)
RTT_API
OperatorRepository::shared_ptr 
operators ()
 This global function provides the short notation for OperatorRepository::Instance()
template<typename function >
UnaryOperator< function > * newUnaryOperator (const char *op, function f)
 helper function to create a new UnaryOperator
template<typename function >
BinaryOperator< function > * newBinaryOperator (const char *op, function f)
 helper function to create a new BinaryOperator
bool RTT_API composePropertyBag (PropertyBag const &sourcebag, PropertyBag &target)
 Uses the type composition to compose all typed properties from a property bag.
bool RTT_API decomposePropertyBag (PropertyBag const &sourcebag, PropertyBag &target)
 Inverse of RTT::types::composePropertyBag().
bool propertyDecomposition (base::PropertyBase *source, PropertyBag &targetbag, bool recurse=true)
 Uses the type decomposition to decompose a property into a property bag that refers to all its parts.
bool typeDecomposition (base::DataSourceBase::shared_ptr source, PropertyBag &targetbag, bool recurse=true)
 Identical to RTT::types::propertyDecomposition(), but takes a DataSourceBase as source.
bool get_container_item (std::vector< bool > &cont, int index)
 Specialisation for vector<bool>, we don't return references to bits aka std::_Bit_reference.
template<class T >
int get_capacity (T const &cont)
 Returns the capacity of an STL container which has the capacity() member function.
template<class T >
int get_size (T const &cont)
 Returns the size of an STL container which has the size() member function.
template<class T >
T::reference get_container_item (T &cont, int index)
 Returns a reference to one item in an STL container.
template<class T >
T::value_type get_container_item_copy (const T &cont, int index)
 Returns a copy to one item in an STL container.
bool get_container_item_copy (const std::vector< bool > &cont, int index)
template<class Function >
TypeBuildernewConstructor (Function *foo, bool automatic=false)
 Create a new Constructor.
template<class Object >
TypeBuildernewConstructor (Object obj, bool automatic=false)
 Create a new Constructor.
TypeInfoRepository::shared_ptr Types ()
 Obtain a pointer to the global type system.
int _EatSpace (std::istream &is, int *countp)
bool Eat (std::istream &is, int delim)
bool EatEnd (std::istream &is, int delim)
std::ostream & operator<< (std::ostream &os, const std::vector< double > &v)
std::istream & operator>> (std::istream &os, std::vector< double > &v)
bool composeProperty (const PropertyBag &bag, std::vector< double > &result)
 A composeProperty method for composing a property of a vector<double> The dimension of the vector must be less than 100.
template<typename T >
std::ostream & operator<< (std::ostream &os, const std::vector< T > &vec)
template<typename T >
std::istream & operator>> (std::istream &is, std::vector< T > &vec)

Detailed Description

Classes for typekits for describing and handling user data types.


Function Documentation

bool RTT::types::composePropertyBag ( PropertyBag const &  sourcebag,
PropertyBag target 
)

Uses the type composition to compose all typed properties from a property bag.

For each PropertyBag found with a type not equal to 'PropertyBag', it will first try to use the user's TypeInfo::composeType function and return that in target if it generates a Property. If composeType did not return anything (because it's not implemented), it will try to create an empty target, decompose it and then updated the decomposition with the sourcebag.

Parameters:
sourcebagContains a PropertyBag to be composed into a known type.
targetThe target type to compose the source bag into.
Returns:
true if all typed PropertyBags in sourcebag could be composed to a user type, false if one or more compositions failed.

Definition at line 10 of file PropertyComposition.cpp.

References RTT::types::TypeInfo::buildProperty(), composePropertyBag(), RTT::types::TypeInfo::composeType(), RTT::PropertyBag::empty(), RTT::base::PropertyBase::getDataSource(), RTT::Property< T >::getDataSource(), RTT::base::PropertyBase::getDescription(), RTT::base::PropertyBase::getName(), RTT::base::PropertyBase::getType(), RTT::PropertyBag::ownProperty(), RTT::base::PropertyBase::ready(), Types(), and RTT::Property< T >::value().

Referenced by composePropertyBag(), RTT::types::BoostArrayTypeInfo< T, has_ostream >::composeType(), RTT::types::SequenceTypeInfoBase< std::vector< double > >::composeType(), RTT::types::CArrayTypeInfo< T, has_ostream >::composeType(), and RTT::marsh::PropertyLoader::load().

bool RTT::types::decomposePropertyBag ( PropertyBag const &  sourcebag,
PropertyBag target 
)

Inverse of RTT::types::composePropertyBag().

This function effectively replaces the property introspection mechanism for decomposition.

Parameters:
sourcebagThe bag from which to compose the type.
targetContains a C++ type to be composed into a hierarchy of properties.
Returns:
True on success, false otherwise.
See also:
RTT::types::propertyComposition

Definition at line 60 of file PropertyComposition.cpp.

References RTT::types::TypeInfo::buildProperty(), decomposePropertyBag(), RTT::PropertyBag::empty(), RTT::base::PropertyBase::getDescription(), RTT::base::PropertyBase::getName(), RTT::base::PropertyBase::getType(), RTT::base::PropertyBase::getTypeInfo(), RTT::PropertyBag::ownProperty(), propertyDecomposition(), RTT::base::PropertyBase::ready(), RTT::internal::DataSource< T >::rvalue(), and RTT::Property< T >::value().

Referenced by decomposePropertyBag().

template<class T >
int RTT::types::get_capacity ( T const &  cont)

Returns the capacity of an STL container which has the capacity() member function.

Parameters:
contA const ref to an STL container.
Returns:
its capacity.

Definition at line 61 of file SequenceTypeInfoBase.hpp.

bool RTT::types::get_container_item ( std::vector< bool > &  cont,
int  index 
)

Specialisation for vector<bool>, we don't return references to bits aka std::_Bit_reference.

vector<bool> is an outlier and should not be used. Use vector<int> or vector<char> instead.

Parameters:
contIs a vector<bool>
indexThe item to read.
Returns:
A copy of the value at position index. not a reference !

Definition at line 45 of file SequenceTypeInfoBase.cpp.

template<class T >
T::reference RTT::types::get_container_item ( T &  cont,
int  index 
)

Returns a reference to one item in an STL container.

Note:
vector<bool> is not supported, since it's not an STL container.
Parameters:
contThe container to access
indexThe item to reference
Returns:
A reference to item index

Definition at line 85 of file SequenceTypeInfoBase.hpp.

template<class T >
T::value_type RTT::types::get_container_item_copy ( const T &  cont,
int  index 
)

Returns a copy to one item in an STL container.

Note:
vector<bool> is not supported, since it's not an STL container.
Parameters:
contThe container to access
indexThe item to extract from the sequence
Returns:
A copy of item index

Definition at line 100 of file SequenceTypeInfoBase.hpp.

template<class T >
int RTT::types::get_size ( T const &  cont)

Returns the size of an STL container which has the size() member function.

Parameters:
contA const ref to an STL container.
Returns:
its size.

Definition at line 72 of file SequenceTypeInfoBase.hpp.

template<class Function >
TypeBuilder* RTT::types::newConstructor ( Function *  foo,
bool  automatic = false 
)

Create a new Constructor.

Parameters:
fooA pointer to the 'C' function which creates an object.
automaticSet to true to allow automatic conversion (without warning) to this type.
Returns:
a Constructor object suitable for the type system.

Definition at line 122 of file TemplateConstructor.hpp.

Referenced by RTT::types::RealTimeTypekitPlugin::loadConstructors().

template<class Object >
TypeBuilder* RTT::types::newConstructor ( Object  obj,
bool  automatic = false 
)

Create a new Constructor.

Parameters:
objA function object which has operator().
automaticSet to true to allow automatic conversion (without warning) to this type.
Returns:
a Constructor object suitable for the type system.

Definition at line 135 of file TemplateConstructor.hpp.

bool RTT_API RTT::types::propertyDecomposition ( base::PropertyBase source,
PropertyBag targetbag,
bool  recurse = true 
)

Uses the type decomposition to decompose a property into a property bag that refers to all its parts.

It will first try to use the user's TypeInfo::decomposeType function and return that in targetbag if it generates a PropertyBag. If it generated something else than a PropertyBag, this function returns false. If decomposeType did not return anything, it will try the TypeInfo::getMember() approach to decompose source into the targetbag. If no members are returned, this function fails.

In case the source type info supports it, each modification of a part in the targetbag will modify source too. This is so for typekits using the boost::serialization functions in combination with TypeInfo::getMember(). In case the type decompositions were written manually using TypeInfo::decomposeType(), this relation can no longer be guaranteed, and a composition step using TypeInfo::composeType() of the same type must be tried to update source with the modifications in targetbag.

For the TypeInfo::getMember() method: This function can only work if every part of the source is known by the RTT type system. Only the parts of source that are assignable will be decomposed. The read-only parts will be silently omitted.

Parameters:
sourceContains a C++ type to be decomposed into a hierarchy of properties.
targetbagThe bag in which to place the result.
Returns:
True on success, false otherwise.

Definition at line 63 of file PropertyDecomposition.cpp.

References RTT::base::PropertyBase::getDataSource(), propertyDecomposition(), and typeDecomposition().

Referenced by decomposePropertyBag(), RTT::base::PropertyBagVisitor::introspectAndDecompose(), propertyDecomposition(), and typeDecomposition().

bool RTT_API RTT::types::typeDecomposition ( base::DataSourceBase::shared_ptr  source,
PropertyBag targetbag,
bool  recurse = true 
)
RTT_API TypeInfoRepository::shared_ptr RTT::types::Types ( )