00001
00002 #ifndef TEST_ROSLIB_COMM_MESSAGE_FILLEMBEDTIME_H
00003 #define TEST_ROSLIB_COMM_MESSAGE_FILLEMBEDTIME_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/String.h"
00014 #include "std_msgs/String.h"
00015
00016 namespace test_roslib_comm
00017 {
00018 template <class ContainerAllocator>
00019 struct FillEmbedTime_ : public ros::Message
00020 {
00021 typedef FillEmbedTime_<ContainerAllocator> Type;
00022
00023 FillEmbedTime_()
00024 : t()
00025 , d()
00026 , str_msg()
00027 , str_msg_array()
00028 , i32(0)
00029 {
00030 }
00031
00032 FillEmbedTime_(const ContainerAllocator& _alloc)
00033 : t()
00034 , d()
00035 , str_msg(_alloc)
00036 , str_msg_array(_alloc)
00037 , i32(0)
00038 {
00039 }
00040
00041 typedef ros::Time _t_type;
00042 ros::Time t;
00043
00044 typedef ros::Duration _d_type;
00045 ros::Duration d;
00046
00047 typedef ::std_msgs::String_<ContainerAllocator> _str_msg_type;
00048 ::std_msgs::String_<ContainerAllocator> str_msg;
00049
00050 typedef std::vector< ::std_msgs::String_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::String_<ContainerAllocator> >::other > _str_msg_array_type;
00051 std::vector< ::std_msgs::String_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::String_<ContainerAllocator> >::other > str_msg_array;
00052
00053 typedef int32_t _i32_type;
00054 int32_t i32;
00055
00056
00057 ROS_DEPRECATED uint32_t get_str_msg_array_size() const { return (uint32_t)str_msg_array.size(); }
00058 ROS_DEPRECATED void set_str_msg_array_size(uint32_t size) { str_msg_array.resize((size_t)size); }
00059 ROS_DEPRECATED void get_str_msg_array_vec(std::vector< ::std_msgs::String_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::String_<ContainerAllocator> >::other > & vec) const { vec = this->str_msg_array; }
00060 ROS_DEPRECATED void set_str_msg_array_vec(const std::vector< ::std_msgs::String_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::std_msgs::String_<ContainerAllocator> >::other > & vec) { this->str_msg_array = vec; }
00061 private:
00062 static const char* __s_getDataType_() { return "test_roslib_comm/FillEmbedTime"; }
00063 public:
00064 ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
00065
00066 ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
00067
00068 private:
00069 static const char* __s_getMD5Sum_() { return "90e08039be001a899b8c20e680c289b0"; }
00070 public:
00071 ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
00072
00073 ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
00074
00075 private:
00076 static const char* __s_getMessageDefinition_() { return "time t\n\
00077 duration d\n\
00078 std_msgs/String str_msg\n\
00079 std_msgs/String[] str_msg_array\n\
00080 int32 i32\n\
00081 ================================================================================\n\
00082 MSG: std_msgs/String\n\
00083 string data\n\
00084 \n\
00085 "; }
00086 public:
00087 ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
00088
00089 ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
00090
00091 ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
00092 {
00093 ros::serialization::OStream stream(write_ptr, 1000000000);
00094 ros::serialization::serialize(stream, t);
00095 ros::serialization::serialize(stream, d);
00096 ros::serialization::serialize(stream, str_msg);
00097 ros::serialization::serialize(stream, str_msg_array);
00098 ros::serialization::serialize(stream, i32);
00099 return stream.getData();
00100 }
00101
00102 ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
00103 {
00104 ros::serialization::IStream stream(read_ptr, 1000000000);
00105 ros::serialization::deserialize(stream, t);
00106 ros::serialization::deserialize(stream, d);
00107 ros::serialization::deserialize(stream, str_msg);
00108 ros::serialization::deserialize(stream, str_msg_array);
00109 ros::serialization::deserialize(stream, i32);
00110 return stream.getData();
00111 }
00112
00113 ROS_DEPRECATED virtual uint32_t serializationLength() const
00114 {
00115 uint32_t size = 0;
00116 size += ros::serialization::serializationLength(t);
00117 size += ros::serialization::serializationLength(d);
00118 size += ros::serialization::serializationLength(str_msg);
00119 size += ros::serialization::serializationLength(str_msg_array);
00120 size += ros::serialization::serializationLength(i32);
00121 return size;
00122 }
00123
00124 typedef boost::shared_ptr< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> > Ptr;
00125 typedef boost::shared_ptr< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> const> ConstPtr;
00126 };
00127 typedef ::test_roslib_comm::FillEmbedTime_<std::allocator<void> > FillEmbedTime;
00128
00129 typedef boost::shared_ptr< ::test_roslib_comm::FillEmbedTime> FillEmbedTimePtr;
00130 typedef boost::shared_ptr< ::test_roslib_comm::FillEmbedTime const> FillEmbedTimeConstPtr;
00131
00132
00133 template<typename ContainerAllocator>
00134 std::ostream& operator<<(std::ostream& s, const ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> & v)
00135 {
00136 ros::message_operations::Printer< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> >::stream(s, "", v);
00137 return s;}
00138
00139 }
00140
00141 namespace ros
00142 {
00143 namespace message_traits
00144 {
00145 template<class ContainerAllocator>
00146 struct MD5Sum< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> > {
00147 static const char* value()
00148 {
00149 return "90e08039be001a899b8c20e680c289b0";
00150 }
00151
00152 static const char* value(const ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> &) { return value(); }
00153 static const uint64_t static_value1 = 0x90e08039be001a89ULL;
00154 static const uint64_t static_value2 = 0x9b8c20e680c289b0ULL;
00155 };
00156
00157 template<class ContainerAllocator>
00158 struct DataType< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> > {
00159 static const char* value()
00160 {
00161 return "test_roslib_comm/FillEmbedTime";
00162 }
00163
00164 static const char* value(const ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> &) { return value(); }
00165 };
00166
00167 template<class ContainerAllocator>
00168 struct Definition< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> > {
00169 static const char* value()
00170 {
00171 return "time t\n\
00172 duration d\n\
00173 std_msgs/String str_msg\n\
00174 std_msgs/String[] str_msg_array\n\
00175 int32 i32\n\
00176 ================================================================================\n\
00177 MSG: std_msgs/String\n\
00178 string data\n\
00179 \n\
00180 ";
00181 }
00182
00183 static const char* value(const ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> &) { return value(); }
00184 };
00185
00186 }
00187 }
00188
00189 namespace ros
00190 {
00191 namespace serialization
00192 {
00193
00194 template<class ContainerAllocator> struct Serializer< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> >
00195 {
00196 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00197 {
00198 stream.next(m.t);
00199 stream.next(m.d);
00200 stream.next(m.str_msg);
00201 stream.next(m.str_msg_array);
00202 stream.next(m.i32);
00203 }
00204
00205 ROS_DECLARE_ALLINONE_SERIALIZER;
00206 };
00207 }
00208 }
00209
00210 namespace ros
00211 {
00212 namespace message_operations
00213 {
00214
00215 template<class ContainerAllocator>
00216 struct Printer< ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> >
00217 {
00218 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::test_roslib_comm::FillEmbedTime_<ContainerAllocator> & v)
00219 {
00220 s << indent << "t: ";
00221 Printer<ros::Time>::stream(s, indent + " ", v.t);
00222 s << indent << "d: ";
00223 Printer<ros::Duration>::stream(s, indent + " ", v.d);
00224 s << indent << "str_msg: ";
00225 s << std::endl;
00226 Printer< ::std_msgs::String_<ContainerAllocator> >::stream(s, indent + " ", v.str_msg);
00227 s << indent << "str_msg_array[]" << std::endl;
00228 for (size_t i = 0; i < v.str_msg_array.size(); ++i)
00229 {
00230 s << indent << " str_msg_array[" << i << "]: ";
00231 s << std::endl;
00232 s << indent;
00233 Printer< ::std_msgs::String_<ContainerAllocator> >::stream(s, indent + " ", v.str_msg_array[i]);
00234 }
00235 s << indent << "i32: ";
00236 Printer<int32_t>::stream(s, indent + " ", v.i32);
00237 }
00238 };
00239
00240
00241 }
00242 }
00243
00244 #endif // TEST_ROSLIB_COMM_MESSAGE_FILLEMBEDTIME_H
00245