00001
00002 #ifndef TEST_ROSJAVA_JNI_MESSAGE_TESTDATATYPES_H
00003 #define TEST_ROSJAVA_JNI_MESSAGE_TESTDATATYPES_H
00004 #include <string>
00005 #include <vector>
00006 #include <ostream>
00007 #include "ros/serialization.h"
00008 #include "ros/builtin_message_traits.h"
00009 #include "ros/message_operations.h"
00010 #include "ros/message.h"
00011 #include "ros/time.h"
00012
00013 #include "std_msgs/Byte.h"
00014 #include "std_msgs/Byte.h"
00015 #include "std_msgs/ByteMultiArray.h"
00016 #include "std_msgs/ByteMultiArray.h"
00017
00018 namespace test_rosjava_jni
00019 {
00020 template <class ContainerAllocator>
00021 struct TestDataTypes_ : public ros::Message
00022 {
00023 typedef TestDataTypes_<ContainerAllocator> Type;
00024
00025 TestDataTypes_()
00026 : byte_(0)
00027 , char_(0)
00028 , uint8_(0)
00029 , int8_(0)
00030 , uint16_(0)
00031 , int16_(0)
00032 , uint32_(0)
00033 , int32_(0)
00034 , uint64_(0)
00035 , int64_(0)
00036 , float32_(0.0)
00037 , float64_(0.0)
00038 , string_()
00039 , time_()
00040 , duration_()
00041 , byte_v()
00042 , byte_f()
00043 , float64_v()
00044 , float64_f()
00045 , string_v()
00046 , string_f()
00047 , time_v()
00048 , time_f()
00049 , Byte_()
00050 , Byte_v()
00051 , ByteMultiArray_()
00052 , ByteMultiArray_v()
00053 {
00054 byte_f.assign(0);
00055 float64_f.assign(0.0);
00056 }
00057
00058 TestDataTypes_(const ContainerAllocator& _alloc)
00059 : byte_(0)
00060 , char_(0)
00061 , uint8_(0)
00062 , int8_(0)
00063 , uint16_(0)
00064 , int16_(0)
00065 , uint32_(0)
00066 , int32_(0)
00067 , uint64_(0)
00068 , int64_(0)
00069 , float32_(0.0)
00070 , float64_(0.0)
00071 , string_(_alloc)
00072 , time_()
00073 , duration_()
00074 , byte_v(_alloc)
00075 , byte_f()
00076 , float64_v(_alloc)
00077 , float64_f()
00078 , string_v(_alloc)
00079 , string_f()
00080 , time_v(_alloc)
00081 , time_f()
00082 , Byte_(_alloc)
00083 , Byte_v(_alloc)
00084 , ByteMultiArray_(_alloc)
00085 , ByteMultiArray_v(_alloc)
00086 {
00087 byte_f.assign(0);
00088 float64_f.assign(0.0);
00089 string_f.assign(std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > (_alloc));
00090 }
00091
00092 typedef int8_t _byte__type;
00093 int8_t byte_;
00094
00095 typedef uint8_t _char__type;
00096 uint8_t char_;
00097
00098 typedef uint8_t _uint8__type;
00099 uint8_t uint8_;
00100
00101 typedef int8_t _int8__type;
00102 int8_t int8_;
00103
00104 typedef uint16_t _uint16__type;
00105 uint16_t uint16_;
00106
00107 typedef int16_t _int16__type;
00108 int16_t int16_;
00109
00110 typedef uint32_t _uint32__type;
00111 uint32_t uint32_;
00112
00113 typedef int32_t _int32__type;
00114 int32_t int32_;
00115
00116 typedef uint64_t _uint64__type;
00117 uint64_t uint64_;
00118
00119 typedef int64_t _int64__type;
00120 int64_t int64_;
00121
00122 typedef float _float32__type;
00123 float float32_;
00124
00125 typedef double _float64__type;
00126 double float64_;
00127
00128 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _string__type;
00129 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > string_;
00130
00131 typedef ros::Time _time__type;
00132 ros::Time time_;
00133
00134 typedef ros::Duration _duration__type;
00135 ros::Duration duration_;
00136
00137 typedef std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other > _byte_v_type;
00138 std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other > byte_v;
00139
00140 typedef boost::array<int8_t, 2> _byte_f_type;
00141 boost::array<int8_t, 2> byte_f;
00142
00143 typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other > _float64_v_type;
00144 std::vector<double, typename ContainerAllocator::template rebind<double>::other > float64_v;
00145
00146 typedef boost::array<double, 2> _float64_f_type;
00147 boost::array<double, 2> float64_f;
00148
00149 typedef std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > _string_v_type;
00150 std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > string_v;
00151
00152 typedef boost::array<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , 2> _string_f_type;
00153 boost::array<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , 2> string_f;
00154
00155 typedef std::vector<ros::Time, typename ContainerAllocator::template rebind<ros::Time>::other > _time_v_type;
00156 std::vector<ros::Time, typename ContainerAllocator::template rebind<ros::Time>::other > time_v;
00157
00158 typedef boost::array<ros::Time, 2> _time_f_type;
00159 boost::array<ros::Time, 2> time_f;
00160
00161 typedef ::std_msgs::Byte_<ContainerAllocator> _Byte__type;
00162 ::std_msgs::Byte_<ContainerAllocator> Byte_;
00163
00164 typedef std::vector< ::std_msgs::Byte_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::Byte_<ContainerAllocator> >::other > _Byte_v_type;
00165 std::vector< ::std_msgs::Byte_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::Byte_<ContainerAllocator> >::other > Byte_v;
00166
00167 typedef ::std_msgs::ByteMultiArray_<ContainerAllocator> _ByteMultiArray__type;
00168 ::std_msgs::ByteMultiArray_<ContainerAllocator> ByteMultiArray_;
00169
00170 typedef std::vector< ::std_msgs::ByteMultiArray_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::ByteMultiArray_<ContainerAllocator> >::other > _ByteMultiArray_v_type;
00171 std::vector< ::std_msgs::ByteMultiArray_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::ByteMultiArray_<ContainerAllocator> >::other > ByteMultiArray_v;
00172
00173
00174 ROS_DEPRECATED uint32_t get_byte_v_size() const { return (uint32_t)byte_v.size(); }
00175 ROS_DEPRECATED void set_byte_v_size(uint32_t size) { byte_v.resize((size_t)size); }
00176 ROS_DEPRECATED void get_byte_v_vec(std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other > & vec) const { vec = this->byte_v; }
00177 ROS_DEPRECATED void set_byte_v_vec(const std::vector<int8_t, typename ContainerAllocator::template rebind<int8_t>::other > & vec) { this->byte_v = vec; }
00178 ROS_DEPRECATED uint32_t get_byte_f_size() const { return (uint32_t)byte_f.size(); }
00179 ROS_DEPRECATED uint32_t get_float64_v_size() const { return (uint32_t)float64_v.size(); }
00180 ROS_DEPRECATED void set_float64_v_size(uint32_t size) { float64_v.resize((size_t)size); }
00181 ROS_DEPRECATED void get_float64_v_vec(std::vector<double, typename ContainerAllocator::template rebind<double>::other > & vec) const { vec = this->float64_v; }
00182 ROS_DEPRECATED void set_float64_v_vec(const std::vector<double, typename ContainerAllocator::template rebind<double>::other > & vec) { this->float64_v = vec; }
00183 ROS_DEPRECATED uint32_t get_float64_f_size() const { return (uint32_t)float64_f.size(); }
00184 ROS_DEPRECATED uint32_t get_string_v_size() const { return (uint32_t)string_v.size(); }
00185 ROS_DEPRECATED void set_string_v_size(uint32_t size) { string_v.resize((size_t)size); }
00186 ROS_DEPRECATED void get_string_v_vec(std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > & vec) const { vec = this->string_v; }
00187 ROS_DEPRECATED void set_string_v_vec(const std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > & vec) { this->string_v = vec; }
00188 ROS_DEPRECATED uint32_t get_string_f_size() const { return (uint32_t)string_f.size(); }
00189 ROS_DEPRECATED uint32_t get_time_v_size() const { return (uint32_t)time_v.size(); }
00190 ROS_DEPRECATED void set_time_v_size(uint32_t size) { time_v.resize((size_t)size); }
00191 ROS_DEPRECATED void get_time_v_vec(std::vector<ros::Time, typename ContainerAllocator::template rebind<ros::Time>::other > & vec) const { vec = this->time_v; }
00192 ROS_DEPRECATED void set_time_v_vec(const std::vector<ros::Time, typename ContainerAllocator::template rebind<ros::Time>::other > & vec) { this->time_v = vec; }
00193 ROS_DEPRECATED uint32_t get_time_f_size() const { return (uint32_t)time_f.size(); }
00194 ROS_DEPRECATED uint32_t get_Byte_v_size() const { return (uint32_t)Byte_v.size(); }
00195 ROS_DEPRECATED void set_Byte_v_size(uint32_t size) { Byte_v.resize((size_t)size); }
00196 ROS_DEPRECATED void get_Byte_v_vec(std::vector< ::std_msgs::Byte_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::Byte_<ContainerAllocator> >::other > & vec) const { vec = this->Byte_v; }
00197 ROS_DEPRECATED void set_Byte_v_vec(const std::vector< ::std_msgs::Byte_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::Byte_<ContainerAllocator> >::other > & vec) { this->Byte_v = vec; }
00198 ROS_DEPRECATED uint32_t get_ByteMultiArray_v_size() const { return (uint32_t)ByteMultiArray_v.size(); }
00199 ROS_DEPRECATED void set_ByteMultiArray_v_size(uint32_t size) { ByteMultiArray_v.resize((size_t)size); }
00200 ROS_DEPRECATED void get_ByteMultiArray_v_vec(std::vector< ::std_msgs::ByteMultiArray_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::ByteMultiArray_<ContainerAllocator> >::other > & vec) const { vec = this->ByteMultiArray_v; }
00201 ROS_DEPRECATED void set_ByteMultiArray_v_vec(const std::vector< ::std_msgs::ByteMultiArray_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::ByteMultiArray_<ContainerAllocator> >::other > & vec) { this->ByteMultiArray_v = vec; }
00202 private:
00203 static const char* __s_getDataType_() { return "test_rosjava_jni/TestDataTypes"; }
00204 public:
00205 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00206
00207 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00208
00209 private:
00210 static const char* __s_getMD5Sum_() { return "25bc379e8ef2913896f76e9ef8bedbdc"; }
00211 public:
00212 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00213
00214 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00215
00216 private:
00217 static const char* __s_getMessageDefinition_() { return "# Test all primitive types\n\
00218 byte byte_\n\
00219 char char_\n\
00220 uint8 uint8_\n\
00221 int8 int8_\n\
00222 uint16 uint16_\n\
00223 int16 int16_\n\
00224 uint32 uint32_\n\
00225 int32 int32_\n\
00226 uint64 uint64_\n\
00227 int64 int64_\n\
00228 float32 float32_\n\
00229 float64 float64_\n\
00230 string string_\n\
00231 time time_\n\
00232 duration duration_\n\
00233 \n\
00234 # Test a smattering of array types\n\
00235 byte[] byte_v\n\
00236 byte[2] byte_f\n\
00237 float64[] float64_v\n\
00238 float64[2] float64_f\n\
00239 string[] string_v\n\
00240 string[2] string_f\n\
00241 time[] time_v\n\
00242 time[2] time_f\n\
00243 \n\
00244 # Test submsgs, including both fixed and var length\n\
00245 std_msgs/Byte Byte_\n\
00246 std_msgs/Byte[] Byte_v\n\
00247 \n\
00248 std_msgs/ByteMultiArray ByteMultiArray_\n\
00249 std_msgs/ByteMultiArray[] ByteMultiArray_v\n\
00250 \n\
00251 # Unfortunately, can't test these because roscpp message generation\n\
00252 # is broken. Hopefully rosjava works correctly ...\n\
00253 # TODO: put these back in.\n\
00254 \n\
00255 # std_msgs/Byte[2] Byte_f\n\
00256 # std_msgs/ByteMultiArray[2] ByteMultiArray_f\n\
00257 \n\
00258 ================================================================================\n\
00259 MSG: std_msgs/Byte\n\
00260 byte data\n\
00261 \n\
00262 ================================================================================\n\
00263 MSG: std_msgs/ByteMultiArray\n\
00264 # Please look at the MultiArrayLayout message definition for\n\
00265 # documentation on all multiarrays.\n\
00266 \n\
00267 MultiArrayLayout layout # specification of data layout\n\
00268 byte[] data # array of data\n\
00269 \n\
00270 \n\
00271 ================================================================================\n\
00272 MSG: std_msgs/MultiArrayLayout\n\
00273 # The multiarray declares a generic multi-dimensional array of a\n\
00274 # particular data type. Dimensions are ordered from outer most\n\
00275 # to inner most.\n\
00276 \n\
00277 MultiArrayDimension[] dim # Array of dimension properties\n\
00278 uint32 data_offset # padding bytes at front of data\n\
00279 \n\
00280 # Accessors should ALWAYS be written in terms of dimension stride\n\
00281 # and specified outer-most dimension first.\n\
00282 # \n\
00283 # multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
00284 #\n\
00285 # A standard, 3-channel 640x480 image with interleaved color channels\n\
00286 # would be specified as:\n\
00287 #\n\
00288 # dim[0].label = \"height\"\n\
00289 # dim[0].size = 480\n\
00290 # dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n\
00291 # dim[1].label = \"width\"\n\
00292 # dim[1].size = 640\n\
00293 # dim[1].stride = 3*640 = 1920\n\
00294 # dim[2].label = \"channel\"\n\
00295 # dim[2].size = 3\n\
00296 # dim[2].stride = 3\n\
00297 #\n\
00298 # multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
00299 ================================================================================\n\
00300 MSG: std_msgs/MultiArrayDimension\n\
00301 string label # label of given dimension\n\
00302 uint32 size # size of given dimension (in type units)\n\
00303 uint32 stride # stride of given dimension\n\
00304 "; }
00305 public:
00306 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00307
00308 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00309
00310 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00311 {
00312 ros::serialization::OStream stream(write_ptr, 1000000000);
00313 ros::serialization::serialize(stream, byte_);
00314 ros::serialization::serialize(stream, char_);
00315 ros::serialization::serialize(stream, uint8_);
00316 ros::serialization::serialize(stream, int8_);
00317 ros::serialization::serialize(stream, uint16_);
00318 ros::serialization::serialize(stream, int16_);
00319 ros::serialization::serialize(stream, uint32_);
00320 ros::serialization::serialize(stream, int32_);
00321 ros::serialization::serialize(stream, uint64_);
00322 ros::serialization::serialize(stream, int64_);
00323 ros::serialization::serialize(stream, float32_);
00324 ros::serialization::serialize(stream, float64_);
00325 ros::serialization::serialize(stream, string_);
00326 ros::serialization::serialize(stream, time_);
00327 ros::serialization::serialize(stream, duration_);
00328 ros::serialization::serialize(stream, byte_v);
00329 ros::serialization::serialize(stream, byte_f);
00330 ros::serialization::serialize(stream, float64_v);
00331 ros::serialization::serialize(stream, float64_f);
00332 ros::serialization::serialize(stream, string_v);
00333 ros::serialization::serialize(stream, string_f);
00334 ros::serialization::serialize(stream, time_v);
00335 ros::serialization::serialize(stream, time_f);
00336 ros::serialization::serialize(stream, Byte_);
00337 ros::serialization::serialize(stream, Byte_v);
00338 ros::serialization::serialize(stream, ByteMultiArray_);
00339 ros::serialization::serialize(stream, ByteMultiArray_v);
00340 return stream.getData();
00341 }
00342
00343 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00344 {
00345 ros::serialization::IStream stream(read_ptr, 1000000000);
00346 ros::serialization::deserialize(stream, byte_);
00347 ros::serialization::deserialize(stream, char_);
00348 ros::serialization::deserialize(stream, uint8_);
00349 ros::serialization::deserialize(stream, int8_);
00350 ros::serialization::deserialize(stream, uint16_);
00351 ros::serialization::deserialize(stream, int16_);
00352 ros::serialization::deserialize(stream, uint32_);
00353 ros::serialization::deserialize(stream, int32_);
00354 ros::serialization::deserialize(stream, uint64_);
00355 ros::serialization::deserialize(stream, int64_);
00356 ros::serialization::deserialize(stream, float32_);
00357 ros::serialization::deserialize(stream, float64_);
00358 ros::serialization::deserialize(stream, string_);
00359 ros::serialization::deserialize(stream, time_);
00360 ros::serialization::deserialize(stream, duration_);
00361 ros::serialization::deserialize(stream, byte_v);
00362 ros::serialization::deserialize(stream, byte_f);
00363 ros::serialization::deserialize(stream, float64_v);
00364 ros::serialization::deserialize(stream, float64_f);
00365 ros::serialization::deserialize(stream, string_v);
00366 ros::serialization::deserialize(stream, string_f);
00367 ros::serialization::deserialize(stream, time_v);
00368 ros::serialization::deserialize(stream, time_f);
00369 ros::serialization::deserialize(stream, Byte_);
00370 ros::serialization::deserialize(stream, Byte_v);
00371 ros::serialization::deserialize(stream, ByteMultiArray_);
00372 ros::serialization::deserialize(stream, ByteMultiArray_v);
00373 return stream.getData();
00374 }
00375
00376 ROS_DEPRECATED virtual uint32_t serializationLength() const
00377 {
00378 uint32_t size = 0;
00379 size += ros::serialization::serializationLength(byte_);
00380 size += ros::serialization::serializationLength(char_);
00381 size += ros::serialization::serializationLength(uint8_);
00382 size += ros::serialization::serializationLength(int8_);
00383 size += ros::serialization::serializationLength(uint16_);
00384 size += ros::serialization::serializationLength(int16_);
00385 size += ros::serialization::serializationLength(uint32_);
00386 size += ros::serialization::serializationLength(int32_);
00387 size += ros::serialization::serializationLength(uint64_);
00388 size += ros::serialization::serializationLength(int64_);
00389 size += ros::serialization::serializationLength(float32_);
00390 size += ros::serialization::serializationLength(float64_);
00391 size += ros::serialization::serializationLength(string_);
00392 size += ros::serialization::serializationLength(time_);
00393 size += ros::serialization::serializationLength(duration_);
00394 size += ros::serialization::serializationLength(byte_v);
00395 size += ros::serialization::serializationLength(byte_f);
00396 size += ros::serialization::serializationLength(float64_v);
00397 size += ros::serialization::serializationLength(float64_f);
00398 size += ros::serialization::serializationLength(string_v);
00399 size += ros::serialization::serializationLength(string_f);
00400 size += ros::serialization::serializationLength(time_v);
00401 size += ros::serialization::serializationLength(time_f);
00402 size += ros::serialization::serializationLength(Byte_);
00403 size += ros::serialization::serializationLength(Byte_v);
00404 size += ros::serialization::serializationLength(ByteMultiArray_);
00405 size += ros::serialization::serializationLength(ByteMultiArray_v);
00406 return size;
00407 }
00408
00409 typedef boost::shared_ptr< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> > Ptr;
00410 typedef boost::shared_ptr< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> const> ConstPtr;
00411 };
00412 typedef ::test_rosjava_jni::TestDataTypes_<std::allocator<void> > TestDataTypes;
00413
00414 typedef boost::shared_ptr< ::test_rosjava_jni::TestDataTypes> TestDataTypesPtr;
00415 typedef boost::shared_ptr< ::test_rosjava_jni::TestDataTypes const> TestDataTypesConstPtr;
00416
00417
00418 template<typename ContainerAllocator>
00419 std::ostream& operator<<(std::ostream& s, const ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> & v)
00420 {
00421 ros::message_operations::Printer< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> >::stream(s, "", v);
00422 return s;}
00423
00424 }
00425
00426 namespace ros
00427 {
00428 namespace message_traits
00429 {
00430 template<class ContainerAllocator>
00431 struct MD5Sum< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> > {
00432 static const char* value()
00433 {
00434 return "25bc379e8ef2913896f76e9ef8bedbdc";
00435 }
00436
00437 static const char* value(const ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> &) { return value(); }
00438 static const uint64_t static_value1 = 0x25bc379e8ef29138ULL;
00439 static const uint64_t static_value2 = 0x96f76e9ef8bedbdcULL;
00440 };
00441
00442 template<class ContainerAllocator>
00443 struct DataType< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> > {
00444 static const char* value()
00445 {
00446 return "test_rosjava_jni/TestDataTypes";
00447 }
00448
00449 static const char* value(const ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> &) { return value(); }
00450 };
00451
00452 template<class ContainerAllocator>
00453 struct Definition< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> > {
00454 static const char* value()
00455 {
00456 return "# Test all primitive types\n\
00457 byte byte_\n\
00458 char char_\n\
00459 uint8 uint8_\n\
00460 int8 int8_\n\
00461 uint16 uint16_\n\
00462 int16 int16_\n\
00463 uint32 uint32_\n\
00464 int32 int32_\n\
00465 uint64 uint64_\n\
00466 int64 int64_\n\
00467 float32 float32_\n\
00468 float64 float64_\n\
00469 string string_\n\
00470 time time_\n\
00471 duration duration_\n\
00472 \n\
00473 # Test a smattering of array types\n\
00474 byte[] byte_v\n\
00475 byte[2] byte_f\n\
00476 float64[] float64_v\n\
00477 float64[2] float64_f\n\
00478 string[] string_v\n\
00479 string[2] string_f\n\
00480 time[] time_v\n\
00481 time[2] time_f\n\
00482 \n\
00483 # Test submsgs, including both fixed and var length\n\
00484 std_msgs/Byte Byte_\n\
00485 std_msgs/Byte[] Byte_v\n\
00486 \n\
00487 std_msgs/ByteMultiArray ByteMultiArray_\n\
00488 std_msgs/ByteMultiArray[] ByteMultiArray_v\n\
00489 \n\
00490 # Unfortunately, can't test these because roscpp message generation\n\
00491 # is broken. Hopefully rosjava works correctly ...\n\
00492 # TODO: put these back in.\n\
00493 \n\
00494 # std_msgs/Byte[2] Byte_f\n\
00495 # std_msgs/ByteMultiArray[2] ByteMultiArray_f\n\
00496 \n\
00497 ================================================================================\n\
00498 MSG: std_msgs/Byte\n\
00499 byte data\n\
00500 \n\
00501 ================================================================================\n\
00502 MSG: std_msgs/ByteMultiArray\n\
00503 # Please look at the MultiArrayLayout message definition for\n\
00504 # documentation on all multiarrays.\n\
00505 \n\
00506 MultiArrayLayout layout # specification of data layout\n\
00507 byte[] data # array of data\n\
00508 \n\
00509 \n\
00510 ================================================================================\n\
00511 MSG: std_msgs/MultiArrayLayout\n\
00512 # The multiarray declares a generic multi-dimensional array of a\n\
00513 # particular data type. Dimensions are ordered from outer most\n\
00514 # to inner most.\n\
00515 \n\
00516 MultiArrayDimension[] dim # Array of dimension properties\n\
00517 uint32 data_offset # padding bytes at front of data\n\
00518 \n\
00519 # Accessors should ALWAYS be written in terms of dimension stride\n\
00520 # and specified outer-most dimension first.\n\
00521 # \n\
00522 # multiarray(i,j,k) = data[data_offset + dim_stride[1]*i + dim_stride[2]*j + k]\n\
00523 #\n\
00524 # A standard, 3-channel 640x480 image with interleaved color channels\n\
00525 # would be specified as:\n\
00526 #\n\
00527 # dim[0].label = \"height\"\n\
00528 # dim[0].size = 480\n\
00529 # dim[0].stride = 3*640*480 = 921600 (note dim[0] stride is just size of image)\n\
00530 # dim[1].label = \"width\"\n\
00531 # dim[1].size = 640\n\
00532 # dim[1].stride = 3*640 = 1920\n\
00533 # dim[2].label = \"channel\"\n\
00534 # dim[2].size = 3\n\
00535 # dim[2].stride = 3\n\
00536 #\n\
00537 # multiarray(i,j,k) refers to the ith row, jth column, and kth channel.\n\
00538 ================================================================================\n\
00539 MSG: std_msgs/MultiArrayDimension\n\
00540 string label # label of given dimension\n\
00541 uint32 size # size of given dimension (in type units)\n\
00542 uint32 stride # stride of given dimension\n\
00543 ";
00544 }
00545
00546 static const char* value(const ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> &) { return value(); }
00547 };
00548
00549 }
00550 }
00551
00552 namespace ros
00553 {
00554 namespace serialization
00555 {
00556
00557 template<class ContainerAllocator> struct Serializer< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> >
00558 {
00559 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00560 {
00561 stream.next(m.byte_);
00562 stream.next(m.char_);
00563 stream.next(m.uint8_);
00564 stream.next(m.int8_);
00565 stream.next(m.uint16_);
00566 stream.next(m.int16_);
00567 stream.next(m.uint32_);
00568 stream.next(m.int32_);
00569 stream.next(m.uint64_);
00570 stream.next(m.int64_);
00571 stream.next(m.float32_);
00572 stream.next(m.float64_);
00573 stream.next(m.string_);
00574 stream.next(m.time_);
00575 stream.next(m.duration_);
00576 stream.next(m.byte_v);
00577 stream.next(m.byte_f);
00578 stream.next(m.float64_v);
00579 stream.next(m.float64_f);
00580 stream.next(m.string_v);
00581 stream.next(m.string_f);
00582 stream.next(m.time_v);
00583 stream.next(m.time_f);
00584 stream.next(m.Byte_);
00585 stream.next(m.Byte_v);
00586 stream.next(m.ByteMultiArray_);
00587 stream.next(m.ByteMultiArray_v);
00588 }
00589
00590 ROS_DECLARE_ALLINONE_SERIALIZER;
00591 };
00592 }
00593 }
00594
00595 namespace ros
00596 {
00597 namespace message_operations
00598 {
00599
00600 template<class ContainerAllocator>
00601 struct Printer< ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> >
00602 {
00603 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::test_rosjava_jni::TestDataTypes_<ContainerAllocator> & v)
00604 {
00605 s << indent << "byte_: ";
00606 Printer<int8_t>::stream(s, indent + " ", v.byte_);
00607 s << indent << "char_: ";
00608 Printer<uint8_t>::stream(s, indent + " ", v.char_);
00609 s << indent << "uint8_: ";
00610 Printer<uint8_t>::stream(s, indent + " ", v.uint8_);
00611 s << indent << "int8_: ";
00612 Printer<int8_t>::stream(s, indent + " ", v.int8_);
00613 s << indent << "uint16_: ";
00614 Printer<uint16_t>::stream(s, indent + " ", v.uint16_);
00615 s << indent << "int16_: ";
00616 Printer<int16_t>::stream(s, indent + " ", v.int16_);
00617 s << indent << "uint32_: ";
00618 Printer<uint32_t>::stream(s, indent + " ", v.uint32_);
00619 s << indent << "int32_: ";
00620 Printer<int32_t>::stream(s, indent + " ", v.int32_);
00621 s << indent << "uint64_: ";
00622 Printer<uint64_t>::stream(s, indent + " ", v.uint64_);
00623 s << indent << "int64_: ";
00624 Printer<int64_t>::stream(s, indent + " ", v.int64_);
00625 s << indent << "float32_: ";
00626 Printer<float>::stream(s, indent + " ", v.float32_);
00627 s << indent << "float64_: ";
00628 Printer<double>::stream(s, indent + " ", v.float64_);
00629 s << indent << "string_: ";
00630 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.string_);
00631 s << indent << "time_: ";
00632 Printer<ros::Time>::stream(s, indent + " ", v.time_);
00633 s << indent << "duration_: ";
00634 Printer<ros::Duration>::stream(s, indent + " ", v.duration_);
00635 s << indent << "byte_v[]" << std::endl;
00636 for (size_t i = 0; i < v.byte_v.size(); ++i)
00637 {
00638 s << indent << " byte_v[" << i << "]: ";
00639 Printer<int8_t>::stream(s, indent + " ", v.byte_v[i]);
00640 }
00641 s << indent << "byte_f[]" << std::endl;
00642 for (size_t i = 0; i < v.byte_f.size(); ++i)
00643 {
00644 s << indent << " byte_f[" << i << "]: ";
00645 Printer<int8_t>::stream(s, indent + " ", v.byte_f[i]);
00646 }
00647 s << indent << "float64_v[]" << std::endl;
00648 for (size_t i = 0; i < v.float64_v.size(); ++i)
00649 {
00650 s << indent << " float64_v[" << i << "]: ";
00651 Printer<double>::stream(s, indent + " ", v.float64_v[i]);
00652 }
00653 s << indent << "float64_f[]" << std::endl;
00654 for (size_t i = 0; i < v.float64_f.size(); ++i)
00655 {
00656 s << indent << " float64_f[" << i << "]: ";
00657 Printer<double>::stream(s, indent + " ", v.float64_f[i]);
00658 }
00659 s << indent << "string_v[]" << std::endl;
00660 for (size_t i = 0; i < v.string_v.size(); ++i)
00661 {
00662 s << indent << " string_v[" << i << "]: ";
00663 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.string_v[i]);
00664 }
00665 s << indent << "string_f[]" << std::endl;
00666 for (size_t i = 0; i < v.string_f.size(); ++i)
00667 {
00668 s << indent << " string_f[" << i << "]: ";
00669 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.string_f[i]);
00670 }
00671 s << indent << "time_v[]" << std::endl;
00672 for (size_t i = 0; i < v.time_v.size(); ++i)
00673 {
00674 s << indent << " time_v[" << i << "]: ";
00675 Printer<ros::Time>::stream(s, indent + " ", v.time_v[i]);
00676 }
00677 s << indent << "time_f[]" << std::endl;
00678 for (size_t i = 0; i < v.time_f.size(); ++i)
00679 {
00680 s << indent << " time_f[" << i << "]: ";
00681 Printer<ros::Time>::stream(s, indent + " ", v.time_f[i]);
00682 }
00683 s << indent << "Byte_: ";
00684 s << std::endl;
00685 Printer< ::std_msgs::Byte_<ContainerAllocator> >::stream(s, indent + " ", v.Byte_);
00686 s << indent << "Byte_v[]" << std::endl;
00687 for (size_t i = 0; i < v.Byte_v.size(); ++i)
00688 {
00689 s << indent << " Byte_v[" << i << "]: ";
00690 s << std::endl;
00691 s << indent;
00692 Printer< ::std_msgs::Byte_<ContainerAllocator> >::stream(s, indent + " ", v.Byte_v[i]);
00693 }
00694 s << indent << "ByteMultiArray_: ";
00695 s << std::endl;
00696 Printer< ::std_msgs::ByteMultiArray_<ContainerAllocator> >::stream(s, indent + " ", v.ByteMultiArray_);
00697 s << indent << "ByteMultiArray_v[]" << std::endl;
00698 for (size_t i = 0; i < v.ByteMultiArray_v.size(); ++i)
00699 {
00700 s << indent << " ByteMultiArray_v[" << i << "]: ";
00701 s << std::endl;
00702 s << indent;
00703 Printer< ::std_msgs::ByteMultiArray_<ContainerAllocator> >::stream(s, indent + " ", v.ByteMultiArray_v[i]);
00704 }
00705 }
00706 };
00707
00708
00709 }
00710 }
00711
00712 #endif // TEST_ROSJAVA_JNI_MESSAGE_TESTDATATYPES_H
00713