Statistics
| Branch: | Revision:

root / vision / msg_gen / cpp / include / vision / TargetDescriptor.h @ 14c71a7d

History | View | Annotate | Download (7.89 KB)

1
/* Auto-generated by genmsg_cpp for file /home/nstanley/ros_workspace/quadrotor/vision/msg/TargetDescriptor.msg */
2
#ifndef VISION_MESSAGE_TARGETDESCRIPTOR_H
3
#define VISION_MESSAGE_TARGETDESCRIPTOR_H
4
#include <string>
5
#include <vector>
6
#include <map>
7
#include <ostream>
8
#include "ros/serialization.h"
9
#include "ros/builtin_message_traits.h"
10
#include "ros/message_operations.h"
11
#include "ros/time.h"
12

    
13
#include "ros/macros.h"
14

    
15
#include "ros/assert.h"
16

    
17
#include "std_msgs/Header.h"
18

    
19
namespace vision
20
{
21
template <class ContainerAllocator>
22
struct TargetDescriptor_ {
23
  typedef TargetDescriptor_<ContainerAllocator> Type;
24

    
25
  TargetDescriptor_()
26
  : header()
27
  , x(0.0)
28
  , y(0.0)
29
  , size(0.0)
30
  {
31
  }
32

    
33
  TargetDescriptor_(const ContainerAllocator& _alloc)
34
  : header(_alloc)
35
  , x(0.0)
36
  , y(0.0)
37
  , size(0.0)
38
  {
39
  }
40

    
41
  typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
42
   ::std_msgs::Header_<ContainerAllocator>  header;
43

    
44
  typedef double _x_type;
45
  double x;
46

    
47
  typedef double _y_type;
48
  double y;
49

    
50
  typedef double _size_type;
51
  double size;
52

    
53

    
54
private:
55
  static const char* __s_getDataType_() { return "vision/TargetDescriptor"; }
56
public:
57
  ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
58

    
59
  ROS_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
60

    
61
private:
62
  static const char* __s_getMD5Sum_() { return "bd12171ec6aa565dd41eff192ff44cfb"; }
63
public:
64
  ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
65

    
66
  ROS_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
67

    
68
private:
69
  static const char* __s_getMessageDefinition_() { return "Header header\n\
70
float64 x\n\
71
float64 y\n\
72
float64 size\n\
73
\n\
74
================================================================================\n\
75
MSG: std_msgs/Header\n\
76
# Standard metadata for higher-level stamped data types.\n\
77
# This is generally used to communicate timestamped data \n\
78
# in a particular coordinate frame.\n\
79
# \n\
80
# sequence ID: consecutively increasing ID \n\
81
uint32 seq\n\
82
#Two-integer timestamp that is expressed as:\n\
83
# * stamp.secs: seconds (stamp_secs) since epoch\n\
84
# * stamp.nsecs: nanoseconds since stamp_secs\n\
85
# time-handling sugar is provided by the client library\n\
86
time stamp\n\
87
#Frame this data is associated with\n\
88
# 0: no frame\n\
89
# 1: global frame\n\
90
string frame_id\n\
91
\n\
92
"; }
93
public:
94
  ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
95

    
96
  ROS_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
97

    
98
  ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
99
  {
100
    ros::serialization::OStream stream(write_ptr, 1000000000);
101
    ros::serialization::serialize(stream, header);
102
    ros::serialization::serialize(stream, x);
103
    ros::serialization::serialize(stream, y);
104
    ros::serialization::serialize(stream, size);
105
    return stream.getData();
106
  }
107

    
108
  ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
109
  {
110
    ros::serialization::IStream stream(read_ptr, 1000000000);
111
    ros::serialization::deserialize(stream, header);
112
    ros::serialization::deserialize(stream, x);
113
    ros::serialization::deserialize(stream, y);
114
    ros::serialization::deserialize(stream, size);
115
    return stream.getData();
116
  }
117

    
118
  ROS_DEPRECATED virtual uint32_t serializationLength() const
119
  {
120
    uint32_t size = 0;
121
    size += ros::serialization::serializationLength(header);
122
    size += ros::serialization::serializationLength(x);
123
    size += ros::serialization::serializationLength(y);
124
    size += ros::serialization::serializationLength(size);
125
    return size;
126
  }
127

    
128
  typedef boost::shared_ptr< ::vision::TargetDescriptor_<ContainerAllocator> > Ptr;
129
  typedef boost::shared_ptr< ::vision::TargetDescriptor_<ContainerAllocator>  const> ConstPtr;
130
  boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
131
}; // struct TargetDescriptor
132
typedef  ::vision::TargetDescriptor_<std::allocator<void> > TargetDescriptor;
133

    
134
typedef boost::shared_ptr< ::vision::TargetDescriptor> TargetDescriptorPtr;
135
typedef boost::shared_ptr< ::vision::TargetDescriptor const> TargetDescriptorConstPtr;
136

    
137

    
138
template<typename ContainerAllocator>
139
std::ostream& operator<<(std::ostream& s, const  ::vision::TargetDescriptor_<ContainerAllocator> & v)
140
{
141
  ros::message_operations::Printer< ::vision::TargetDescriptor_<ContainerAllocator> >::stream(s, "", v);
142
  return s;}
143

    
144
} // namespace vision
145

    
146
namespace ros
147
{
148
namespace message_traits
149
{
150
template<class ContainerAllocator> struct IsMessage< ::vision::TargetDescriptor_<ContainerAllocator> > : public TrueType {};
151
template<class ContainerAllocator> struct IsMessage< ::vision::TargetDescriptor_<ContainerAllocator>  const> : public TrueType {};
152
template<class ContainerAllocator>
153
struct MD5Sum< ::vision::TargetDescriptor_<ContainerAllocator> > {
154
  static const char* value() 
155
  {
156
    return "bd12171ec6aa565dd41eff192ff44cfb";
157
  }
158

    
159
  static const char* value(const  ::vision::TargetDescriptor_<ContainerAllocator> &) { return value(); } 
160
  static const uint64_t static_value1 = 0xbd12171ec6aa565dULL;
161
  static const uint64_t static_value2 = 0xd41eff192ff44cfbULL;
162
};
163

    
164
template<class ContainerAllocator>
165
struct DataType< ::vision::TargetDescriptor_<ContainerAllocator> > {
166
  static const char* value() 
167
  {
168
    return "vision/TargetDescriptor";
169
  }
170

    
171
  static const char* value(const  ::vision::TargetDescriptor_<ContainerAllocator> &) { return value(); } 
172
};
173

    
174
template<class ContainerAllocator>
175
struct Definition< ::vision::TargetDescriptor_<ContainerAllocator> > {
176
  static const char* value() 
177
  {
178
    return "Header header\n\
179
float64 x\n\
180
float64 y\n\
181
float64 size\n\
182
\n\
183
================================================================================\n\
184
MSG: std_msgs/Header\n\
185
# Standard metadata for higher-level stamped data types.\n\
186
# This is generally used to communicate timestamped data \n\
187
# in a particular coordinate frame.\n\
188
# \n\
189
# sequence ID: consecutively increasing ID \n\
190
uint32 seq\n\
191
#Two-integer timestamp that is expressed as:\n\
192
# * stamp.secs: seconds (stamp_secs) since epoch\n\
193
# * stamp.nsecs: nanoseconds since stamp_secs\n\
194
# time-handling sugar is provided by the client library\n\
195
time stamp\n\
196
#Frame this data is associated with\n\
197
# 0: no frame\n\
198
# 1: global frame\n\
199
string frame_id\n\
200
\n\
201
";
202
  }
203

    
204
  static const char* value(const  ::vision::TargetDescriptor_<ContainerAllocator> &) { return value(); } 
205
};
206

    
207
template<class ContainerAllocator> struct HasHeader< ::vision::TargetDescriptor_<ContainerAllocator> > : public TrueType {};
208
template<class ContainerAllocator> struct HasHeader< const ::vision::TargetDescriptor_<ContainerAllocator> > : public TrueType {};
209
} // namespace message_traits
210
} // namespace ros
211

    
212
namespace ros
213
{
214
namespace serialization
215
{
216

    
217
template<class ContainerAllocator> struct Serializer< ::vision::TargetDescriptor_<ContainerAllocator> >
218
{
219
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
220
  {
221
    stream.next(m.header);
222
    stream.next(m.x);
223
    stream.next(m.y);
224
    stream.next(m.size);
225
  }
226

    
227
  ROS_DECLARE_ALLINONE_SERIALIZER;
228
}; // struct TargetDescriptor_
229
} // namespace serialization
230
} // namespace ros
231

    
232
namespace ros
233
{
234
namespace message_operations
235
{
236

    
237
template<class ContainerAllocator>
238
struct Printer< ::vision::TargetDescriptor_<ContainerAllocator> >
239
{
240
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::vision::TargetDescriptor_<ContainerAllocator> & v) 
241
  {
242
    s << indent << "header: ";
243
s << std::endl;
244
    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
245
    s << indent << "x: ";
246
    Printer<double>::stream(s, indent + "  ", v.x);
247
    s << indent << "y: ";
248
    Printer<double>::stream(s, indent + "  ", v.y);
249
    s << indent << "size: ";
250
    Printer<double>::stream(s, indent + "  ", v.size);
251
  }
252
};
253

    
254

    
255
} // namespace message_operations
256
} // namespace ros
257

    
258
#endif // VISION_MESSAGE_TARGETDESCRIPTOR_H
259