Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040 #include "rtt-typekit-config.h"
00041 #include "RealTimeTypekit.hpp"
00042 #include "../types/Types.hpp"
00043 #include "../FlowStatus.hpp"
00044 #include "../ConnPolicy.hpp"
00045 #include "../internal/DataSources.hpp"
00046 #include "../typekit/Types.hpp"
00047 #include "../rtt-fwd.hpp"
00048 #include "../internal/mystd.hpp"
00049 #include "../types/TemplateConstructor.hpp"
00050 #ifdef OS_RT_MALLOC
00051 #include "../rt_string.hpp"
00052 #endif
00053
00054 namespace RTT
00055 {
00056 using namespace std;
00057 using namespace detail;
00058
00059 namespace {
00060 #ifndef ORO_EMBEDDED
00061
00062 struct array_ctor
00063 : public std::unary_function<int, const std::vector<double>&>
00064 {
00065 typedef const std::vector<double>& (Signature)( int );
00066 mutable boost::shared_ptr< std::vector<double> > ptr;
00067 array_ctor()
00068 : ptr( new std::vector<double>() ) {}
00069 const std::vector<double>& operator()( int size ) const
00070 {
00071 ptr->resize( size );
00072 return *(ptr);
00073 }
00074 };
00075
00080 struct array_varargs_ctor
00081 {
00082 typedef const std::vector<double>& result_type;
00083 typedef double argument_type;
00084 result_type operator()( const std::vector<double>& args ) const
00085 {
00086 return args;
00087 }
00088 };
00089
00094 typedef NArityDataSource<array_varargs_ctor> ArrayDataSource;
00095
00100 struct ArrayBuilder
00101 : public TypeConstructor
00102 {
00103 virtual DataSourceBase::shared_ptr build(const std::vector<DataSourceBase::shared_ptr>& args) const {
00104 if (args.size() == 0 )
00105 return DataSourceBase::shared_ptr();
00106 ArrayDataSource::shared_ptr vds = new ArrayDataSource();
00107 for(unsigned int i=0; i != args.size(); ++i) {
00108 DataSource<double>::shared_ptr dsd = boost::dynamic_pointer_cast< DataSource<double> >( args[i] );
00109 if (dsd)
00110 vds->add( dsd );
00111 else
00112 return DataSourceBase::shared_ptr();
00113 }
00114 return vds;
00115 }
00116
00117 };
00118
00119 struct array_ctor2
00120 : public std::binary_function<int, double, const std::vector<double>&>
00121 {
00122 typedef const std::vector<double>& (Signature)( int, double );
00123 mutable boost::shared_ptr< std::vector<double> > ptr;
00124 array_ctor2()
00125 : ptr( new std::vector<double>() ) {}
00126 const std::vector<double>& operator()( int size, double value ) const
00127 {
00128 ptr->resize( size );
00129 ptr->assign( size, value );
00130 return *(ptr);
00131 }
00132 };
00133
00134 double float_to_double( float val ) {return double(val);}
00135 float double_to_float( double val ) {return float(val);}
00136
00137
00138 int float_to_int(float f) { return int(f); }
00139 float int_to_float(int i) { return float(i); }
00140 int double_to_int(double f) { return int(f); }
00141 double int_to_double(int i) { return double(i); }
00142 unsigned int int_to_uint(int i) { return (unsigned int)(i); }
00143 int uint_to_int(unsigned int ui) { return int(ui); }
00144 #endif
00145 bool flow_to_bool(FlowStatus fs) { return fs != NoData ; }
00146 bool send_to_bool(SendStatus ss) { return ss == SendSuccess; }
00147 bool int_to_bool(int i) { return i != 0; }
00148 int bool_to_int(bool b) { return int(b); }
00149
00150 struct string_ctor
00151 : public std::unary_function<int, const std::string&>
00152 {
00153 mutable boost::shared_ptr< std::string > ptr;
00154 typedef const std::string& (Signature)( int );
00155 string_ctor()
00156 : ptr( new std::string() ) {}
00157 const std::string& operator()( int size ) const
00158 {
00159 ptr->resize( size );
00160 return *(ptr);
00161 }
00162 };
00163
00164 #ifdef OS_RT_MALLOC
00165 struct rt_string_ctor_int
00166 : public std::unary_function<int, const RTT::rt_string&>
00167 {
00168 mutable boost::shared_ptr< rt_string > ptr;
00169 typedef const rt_string& (Signature)( int );
00170 rt_string_ctor_int()
00171 : ptr( new rt_string() ) {}
00172 const rt_string& operator()( int size ) const
00173 {
00174 ptr->resize( size );
00175 return *(ptr);
00176 }
00177 };
00178
00179 struct rt_string_ctor_string
00180 : public std::unary_function<const std::string&, const RTT::rt_string&>
00181 {
00182 mutable boost::shared_ptr< rt_string > ptr;
00183 typedef const rt_string& (Signature)( std::string const& );
00184 rt_string_ctor_string()
00185 : ptr( new rt_string() ) {}
00186 const rt_string& operator()( std::string const& arg ) const
00187 {
00188 *ptr = arg.c_str();
00189 return *(ptr);
00190 }
00191 };
00192
00193 struct string_ctor_rt_string
00194 : public std::unary_function<const rt_string&, const string&>
00195 {
00196 mutable boost::shared_ptr< string > ptr;
00197 typedef const string& (Signature)( rt_string const& );
00198 string_ctor_rt_string()
00199 : ptr( new string() ) {}
00200 const string& operator()( rt_string const& arg ) const
00201 {
00202 *ptr = arg.c_str();
00203 return *(ptr);
00204 }
00205 };
00206
00207 #endif
00208 }
00209
00210 bool RealTimeTypekitPlugin::loadConstructors()
00211 {
00212 TypeInfoRepository::shared_ptr ti = TypeInfoRepository::Instance();
00213 #ifndef ORO_EMBEDDED
00214 ti->type("double")->addConstructor( newConstructor( &float_to_double, true ));
00215 ti->type("double")->addConstructor( newConstructor( &int_to_double, true ));
00216 ti->type("float")->addConstructor( newConstructor( &int_to_float, true ));
00217 ti->type("float")->addConstructor( newConstructor( &double_to_float, true ));
00218 ti->type("int")->addConstructor( newConstructor( &float_to_int, false ));
00219 ti->type("int")->addConstructor( newConstructor( &double_to_int, false ));
00220 ti->type("int")->addConstructor( newConstructor( &uint_to_int, true ));
00221 ti->type("int")->addConstructor( newConstructor( &bool_to_int, true ));
00222 ti->type("uint")->addConstructor( newConstructor( &int_to_uint, true ));
00223 ti->type("string")->addConstructor( newConstructor( string_ctor() ) );
00224 #ifdef OS_RT_MALLOC
00225 ti->type("rt_string")->addConstructor( newConstructor( rt_string_ctor_int() ) );
00226 ti->type("rt_string")->addConstructor( newConstructor( rt_string_ctor_string() ) );
00227 ti->type("string")->addConstructor( newConstructor( string_ctor_rt_string() ) );
00228 #endif
00229 ti->type("bool")->addConstructor( newConstructor( &flow_to_bool, true ) );
00230 ti->type("bool")->addConstructor( newConstructor( &send_to_bool, true ) );
00231 ti->type("bool")->addConstructor( newConstructor( &int_to_bool, true ) );
00232 #endif
00233 return true;
00234 }
00235 }