00001
00002 #ifndef WPA_SUPPLICANT_NODE_MESSAGE_BSS_H
00003 #define WPA_SUPPLICANT_NODE_MESSAGE_BSS_H
00004 #include <string>
00005 #include <vector>
00006 #include <map>
00007 #include <ostream>
00008 #include "ros/serialization.h"
00009 #include "ros/builtin_message_traits.h"
00010 #include "ros/message_operations.h"
00011 #include "ros/time.h"
00012
00013 #include "ros/macros.h"
00014
00015 #include "ros/assert.h"
00016
00017 #include "wpa_supplicant_node/SecurityProperties.h"
00018 #include "wpa_supplicant_node/SecurityProperties.h"
00019
00020 namespace wpa_supplicant_node
00021 {
00022 template <class ContainerAllocator>
00023 struct Bss_ {
00024 typedef Bss_<ContainerAllocator> Type;
00025
00026 Bss_()
00027 : stamp()
00028 , ssid()
00029 , bssid()
00030 , frequency(0)
00031 , beacon_interval(0)
00032 , capabilities(0)
00033 , quality(0)
00034 , noise(0)
00035 , level(0)
00036 , wpa()
00037 , rsn()
00038 {
00039 bssid.assign(0);
00040 }
00041
00042 Bss_(const ContainerAllocator& _alloc)
00043 : stamp()
00044 , ssid(_alloc)
00045 , bssid()
00046 , frequency(0)
00047 , beacon_interval(0)
00048 , capabilities(0)
00049 , quality(0)
00050 , noise(0)
00051 , level(0)
00052 , wpa(_alloc)
00053 , rsn(_alloc)
00054 {
00055 bssid.assign(0);
00056 }
00057
00058 typedef ros::Time _stamp_type;
00059 ros::Time stamp;
00060
00061 typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _ssid_type;
00062 std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > ssid;
00063
00064 typedef boost::array<uint8_t, 6> _bssid_type;
00065 boost::array<uint8_t, 6> bssid;
00066
00067 typedef int32_t _frequency_type;
00068 int32_t frequency;
00069
00070 typedef int16_t _beacon_interval_type;
00071 int16_t beacon_interval;
00072
00073 typedef int16_t _capabilities_type;
00074 int16_t capabilities;
00075
00076 typedef int32_t _quality_type;
00077 int32_t quality;
00078
00079 typedef int32_t _noise_type;
00080 int32_t noise;
00081
00082 typedef int32_t _level_type;
00083 int32_t level;
00084
00085 typedef ::wpa_supplicant_node::SecurityProperties_<ContainerAllocator> _wpa_type;
00086 ::wpa_supplicant_node::SecurityProperties_<ContainerAllocator> wpa;
00087
00088 typedef ::wpa_supplicant_node::SecurityProperties_<ContainerAllocator> _rsn_type;
00089 ::wpa_supplicant_node::SecurityProperties_<ContainerAllocator> rsn;
00090
00091
00092 typedef boost::shared_ptr< ::wpa_supplicant_node::Bss_<ContainerAllocator> > Ptr;
00093 typedef boost::shared_ptr< ::wpa_supplicant_node::Bss_<ContainerAllocator> const> ConstPtr;
00094 boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
00095 };
00096 typedef ::wpa_supplicant_node::Bss_<std::allocator<void> > Bss;
00097
00098 typedef boost::shared_ptr< ::wpa_supplicant_node::Bss> BssPtr;
00099 typedef boost::shared_ptr< ::wpa_supplicant_node::Bss const> BssConstPtr;
00100
00101
00102 template<typename ContainerAllocator>
00103 std::ostream& operator<<(std::ostream& s, const ::wpa_supplicant_node::Bss_<ContainerAllocator> & v)
00104 {
00105 ros::message_operations::Printer< ::wpa_supplicant_node::Bss_<ContainerAllocator> >::stream(s, "", v);
00106 return s;}
00107
00108 }
00109
00110 namespace ros
00111 {
00112 namespace message_traits
00113 {
00114 template<class ContainerAllocator> struct IsMessage< ::wpa_supplicant_node::Bss_<ContainerAllocator> > : public TrueType {};
00115 template<class ContainerAllocator> struct IsMessage< ::wpa_supplicant_node::Bss_<ContainerAllocator> const> : public TrueType {};
00116 template<class ContainerAllocator>
00117 struct MD5Sum< ::wpa_supplicant_node::Bss_<ContainerAllocator> > {
00118 static const char* value()
00119 {
00120 return "80facb0ec718ef7a27a68ac18771763a";
00121 }
00122
00123 static const char* value(const ::wpa_supplicant_node::Bss_<ContainerAllocator> &) { return value(); }
00124 static const uint64_t static_value1 = 0x80facb0ec718ef7aULL;
00125 static const uint64_t static_value2 = 0x27a68ac18771763aULL;
00126 };
00127
00128 template<class ContainerAllocator>
00129 struct DataType< ::wpa_supplicant_node::Bss_<ContainerAllocator> > {
00130 static const char* value()
00131 {
00132 return "wpa_supplicant_node/Bss";
00133 }
00134
00135 static const char* value(const ::wpa_supplicant_node::Bss_<ContainerAllocator> &) { return value(); }
00136 };
00137
00138 template<class ContainerAllocator>
00139 struct Definition< ::wpa_supplicant_node::Bss_<ContainerAllocator> > {
00140 static const char* value()
00141 {
00142 return "time stamp\n\
00143 string ssid\n\
00144 uint8[6] bssid\n\
00145 int32 frequency # In MHz\n\
00146 int16 beacon_interval\n\
00147 int16 capabilities\n\
00148 int32 quality\n\
00149 int32 noise\n\
00150 int32 level\n\
00151 SecurityProperties wpa\n\
00152 SecurityProperties rsn\n\
00153 \n\
00154 #InformationElement []ies\n\
00155 #InformationElement []beacon_ies\n\
00156 # flags\n\
00157 # tsf\n\
00158 # age\n\
00159 \n\
00160 ================================================================================\n\
00161 MSG: wpa_supplicant_node/SecurityProperties\n\
00162 string[] key_mgmt\n\
00163 string[] group\n\
00164 string[] pairwise\n\
00165 \n\
00166 ";
00167 }
00168
00169 static const char* value(const ::wpa_supplicant_node::Bss_<ContainerAllocator> &) { return value(); }
00170 };
00171
00172 }
00173 }
00174
00175 namespace ros
00176 {
00177 namespace serialization
00178 {
00179
00180 template<class ContainerAllocator> struct Serializer< ::wpa_supplicant_node::Bss_<ContainerAllocator> >
00181 {
00182 template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
00183 {
00184 stream.next(m.stamp);
00185 stream.next(m.ssid);
00186 stream.next(m.bssid);
00187 stream.next(m.frequency);
00188 stream.next(m.beacon_interval);
00189 stream.next(m.capabilities);
00190 stream.next(m.quality);
00191 stream.next(m.noise);
00192 stream.next(m.level);
00193 stream.next(m.wpa);
00194 stream.next(m.rsn);
00195 }
00196
00197 ROS_DECLARE_ALLINONE_SERIALIZER;
00198 };
00199 }
00200 }
00201
00202 namespace ros
00203 {
00204 namespace message_operations
00205 {
00206
00207 template<class ContainerAllocator>
00208 struct Printer< ::wpa_supplicant_node::Bss_<ContainerAllocator> >
00209 {
00210 template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::wpa_supplicant_node::Bss_<ContainerAllocator> & v)
00211 {
00212 s << indent << "stamp: ";
00213 Printer<ros::Time>::stream(s, indent + " ", v.stamp);
00214 s << indent << "ssid: ";
00215 Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.ssid);
00216 s << indent << "bssid[]" << std::endl;
00217 for (size_t i = 0; i < v.bssid.size(); ++i)
00218 {
00219 s << indent << " bssid[" << i << "]: ";
00220 Printer<uint8_t>::stream(s, indent + " ", v.bssid[i]);
00221 }
00222 s << indent << "frequency: ";
00223 Printer<int32_t>::stream(s, indent + " ", v.frequency);
00224 s << indent << "beacon_interval: ";
00225 Printer<int16_t>::stream(s, indent + " ", v.beacon_interval);
00226 s << indent << "capabilities: ";
00227 Printer<int16_t>::stream(s, indent + " ", v.capabilities);
00228 s << indent << "quality: ";
00229 Printer<int32_t>::stream(s, indent + " ", v.quality);
00230 s << indent << "noise: ";
00231 Printer<int32_t>::stream(s, indent + " ", v.noise);
00232 s << indent << "level: ";
00233 Printer<int32_t>::stream(s, indent + " ", v.level);
00234 s << indent << "wpa: ";
00235 s << std::endl;
00236 Printer< ::wpa_supplicant_node::SecurityProperties_<ContainerAllocator> >::stream(s, indent + " ", v.wpa);
00237 s << indent << "rsn: ";
00238 s << std::endl;
00239 Printer< ::wpa_supplicant_node::SecurityProperties_<ContainerAllocator> >::stream(s, indent + " ", v.rsn);
00240 }
00241 };
00242
00243
00244 }
00245 }
00246
00247 #endif // WPA_SUPPLICANT_NODE_MESSAGE_BSS_H
00248