UdpMonitor.h

Go to the documentation of this file.

/* Auto-generated by genmsg_cpp for file /tmp/buildd/ros-diamondback-linux-networking-0.1.6/debian/ros-diamondback-linux-networking/opt/ros/diamondback/stacks/linux_networking/network_monitor_udp/msg/UdpMonitor.msg */
#ifndef NETWORK_MONITOR_UDP_MESSAGE_UDPMONITOR_H
#define NETWORK_MONITOR_UDP_MESSAGE_UDPMONITOR_H
#include <string>
#include <vector>
#include <ostream>
#include "ros/serialization.h"
#include "ros/builtin_message_traits.h"
#include "ros/message_operations.h"
#include "ros/message.h"
#include "ros/time.h"

#include "std_msgs/Header.h"

namespace network_monitor_udp
{
template <class ContainerAllocator>
struct UdpMonitor_ : public ros::Message
{
  typedef UdpMonitor_<ContainerAllocator> Type;

  UdpMonitor_()
  : header()
  , server_host()
  , server_port(0)
  , source_interface()
  , packet_rate(0.0)
  , packet_size(0)
  , latency_bin_limits()
  , latency_bin_values()
  , average_latency_fresh(0.0)
  , loss_fresh(0.0)
  , average_latency_all(0.0)
  {
  }

  UdpMonitor_(const ContainerAllocator& _alloc)
  : header(_alloc)
  , server_host(_alloc)
  , server_port(0)
  , source_interface(_alloc)
  , packet_rate(0.0)
  , packet_size(0)
  , latency_bin_limits(_alloc)
  , latency_bin_values(_alloc)
  , average_latency_fresh(0.0)
  , loss_fresh(0.0)
  , average_latency_all(0.0)
  {
  }

  typedef  ::std_msgs::Header_<ContainerAllocator>  _header_type;
   ::std_msgs::Header_<ContainerAllocator>  header;

  typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _server_host_type;
  std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  server_host;

  typedef uint32_t _server_port_type;
  uint32_t server_port;

  typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _source_interface_type;
  std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  source_interface;

  typedef float _packet_rate_type;
  float packet_rate;

  typedef uint32_t _packet_size_type;
  uint32_t packet_size;

  typedef std::vector<float, typename ContainerAllocator::template rebind<float>::other >  _latency_bin_limits_type;
  std::vector<float, typename ContainerAllocator::template rebind<float>::other >  latency_bin_limits;

  typedef std::vector<float, typename ContainerAllocator::template rebind<float>::other >  _latency_bin_values_type;
  std::vector<float, typename ContainerAllocator::template rebind<float>::other >  latency_bin_values;

  typedef float _average_latency_fresh_type;
  float average_latency_fresh;

  typedef float _loss_fresh_type;
  float loss_fresh;

  typedef float _average_latency_all_type;
  float average_latency_all;


  ROS_DEPRECATED uint32_t get_latency_bin_limits_size() const { return (uint32_t)latency_bin_limits.size(); }
  ROS_DEPRECATED void set_latency_bin_limits_size(uint32_t size) { latency_bin_limits.resize((size_t)size); }
  ROS_DEPRECATED void get_latency_bin_limits_vec(std::vector<float, typename ContainerAllocator::template rebind<float>::other > & vec) const { vec = this->latency_bin_limits; }
  ROS_DEPRECATED void set_latency_bin_limits_vec(const std::vector<float, typename ContainerAllocator::template rebind<float>::other > & vec) { this->latency_bin_limits = vec; }
  ROS_DEPRECATED uint32_t get_latency_bin_values_size() const { return (uint32_t)latency_bin_values.size(); }
  ROS_DEPRECATED void set_latency_bin_values_size(uint32_t size) { latency_bin_values.resize((size_t)size); }
  ROS_DEPRECATED void get_latency_bin_values_vec(std::vector<float, typename ContainerAllocator::template rebind<float>::other > & vec) const { vec = this->latency_bin_values; }
  ROS_DEPRECATED void set_latency_bin_values_vec(const std::vector<float, typename ContainerAllocator::template rebind<float>::other > & vec) { this->latency_bin_values = vec; }
private:
  static const char* __s_getDataType_() { return "network_monitor_udp/UdpMonitor"; }
public:
  ROS_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }

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

private:
  static const char* __s_getMD5Sum_() { return "61e78eeecffb9257ae40ca291408f8cc"; }
public:
  ROS_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }

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

private:
  static const char* __s_getMessageDefinition_() { return "Header header\n\
\n\
# Summary of the client settings\n\
string server_host\n\
uint32 server_port\n\
string source_interface\n\
float32 packet_rate\n\
uint32 packet_size\n\
\n\
# Proportion of packets that have latencies within a bin. The first bin\n\
# starts at zero, bins end at the value in latency_bin_values. \n\
# len(latency_bin_values) = len(latency_bin_limits) + 1\n\
float32[] latency_bin_limits\n\
float32[] latency_bin_values\n\
\n\
# Average latency in seconds and loss rate (between 0 and 1) for packets\n\
# that fall within one of the bins.\n\
float32 average_latency_fresh\n\
float32 loss_fresh\n\
\n\
# Average latency in seconds for all\n\
# received packets, including very old ones.\n\
float32 average_latency_all\n\
\n\
================================================================================\n\
MSG: std_msgs/Header\n\
# Standard metadata for higher-level stamped data types.\n\
# This is generally used to communicate timestamped data \n\
# in a particular coordinate frame.\n\
# \n\
# sequence ID: consecutively increasing ID \n\
uint32 seq\n\
#Two-integer timestamp that is expressed as:\n\
# * stamp.secs: seconds (stamp_secs) since epoch\n\
# * stamp.nsecs: nanoseconds since stamp_secs\n\
# time-handling sugar is provided by the client library\n\
time stamp\n\
#Frame this data is associated with\n\
# 0: no frame\n\
# 1: global frame\n\
string frame_id\n\
\n\
"; }
public:
  ROS_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }

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

  ROS_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
  {
    ros::serialization::OStream stream(write_ptr, 1000000000);
    ros::serialization::serialize(stream, header);
    ros::serialization::serialize(stream, server_host);
    ros::serialization::serialize(stream, server_port);
    ros::serialization::serialize(stream, source_interface);
    ros::serialization::serialize(stream, packet_rate);
    ros::serialization::serialize(stream, packet_size);
    ros::serialization::serialize(stream, latency_bin_limits);
    ros::serialization::serialize(stream, latency_bin_values);
    ros::serialization::serialize(stream, average_latency_fresh);
    ros::serialization::serialize(stream, loss_fresh);
    ros::serialization::serialize(stream, average_latency_all);
    return stream.getData();
  }

  ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
  {
    ros::serialization::IStream stream(read_ptr, 1000000000);
    ros::serialization::deserialize(stream, header);
    ros::serialization::deserialize(stream, server_host);
    ros::serialization::deserialize(stream, server_port);
    ros::serialization::deserialize(stream, source_interface);
    ros::serialization::deserialize(stream, packet_rate);
    ros::serialization::deserialize(stream, packet_size);
    ros::serialization::deserialize(stream, latency_bin_limits);
    ros::serialization::deserialize(stream, latency_bin_values);
    ros::serialization::deserialize(stream, average_latency_fresh);
    ros::serialization::deserialize(stream, loss_fresh);
    ros::serialization::deserialize(stream, average_latency_all);
    return stream.getData();
  }

  ROS_DEPRECATED virtual uint32_t serializationLength() const
  {
    uint32_t size = 0;
    size += ros::serialization::serializationLength(header);
    size += ros::serialization::serializationLength(server_host);
    size += ros::serialization::serializationLength(server_port);
    size += ros::serialization::serializationLength(source_interface);
    size += ros::serialization::serializationLength(packet_rate);
    size += ros::serialization::serializationLength(packet_size);
    size += ros::serialization::serializationLength(latency_bin_limits);
    size += ros::serialization::serializationLength(latency_bin_values);
    size += ros::serialization::serializationLength(average_latency_fresh);
    size += ros::serialization::serializationLength(loss_fresh);
    size += ros::serialization::serializationLength(average_latency_all);
    return size;
  }

  typedef boost::shared_ptr< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::network_monitor_udp::UdpMonitor_<ContainerAllocator>  const> ConstPtr;
}; // struct UdpMonitor
typedef  ::network_monitor_udp::UdpMonitor_<std::allocator<void> > UdpMonitor;

typedef boost::shared_ptr< ::network_monitor_udp::UdpMonitor> UdpMonitorPtr;
typedef boost::shared_ptr< ::network_monitor_udp::UdpMonitor const> UdpMonitorConstPtr;


template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const  ::network_monitor_udp::UdpMonitor_<ContainerAllocator> & v)
{
  ros::message_operations::Printer< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> >::stream(s, "", v);
  return s;}

} // namespace network_monitor_udp

namespace ros
{
namespace message_traits
{
template<class ContainerAllocator>
struct MD5Sum< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> > {
  static const char* value() 
  {
    return "61e78eeecffb9257ae40ca291408f8cc";
  }

  static const char* value(const  ::network_monitor_udp::UdpMonitor_<ContainerAllocator> &) { return value(); } 
  static const uint64_t static_value1 = 0x61e78eeecffb9257ULL;
  static const uint64_t static_value2 = 0xae40ca291408f8ccULL;
};

template<class ContainerAllocator>
struct DataType< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> > {
  static const char* value() 
  {
    return "network_monitor_udp/UdpMonitor";
  }

  static const char* value(const  ::network_monitor_udp::UdpMonitor_<ContainerAllocator> &) { return value(); } 
};

template<class ContainerAllocator>
struct Definition< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> > {
  static const char* value() 
  {
    return "Header header\n\
\n\
# Summary of the client settings\n\
string server_host\n\
uint32 server_port\n\
string source_interface\n\
float32 packet_rate\n\
uint32 packet_size\n\
\n\
# Proportion of packets that have latencies within a bin. The first bin\n\
# starts at zero, bins end at the value in latency_bin_values. \n\
# len(latency_bin_values) = len(latency_bin_limits) + 1\n\
float32[] latency_bin_limits\n\
float32[] latency_bin_values\n\
\n\
# Average latency in seconds and loss rate (between 0 and 1) for packets\n\
# that fall within one of the bins.\n\
float32 average_latency_fresh\n\
float32 loss_fresh\n\
\n\
# Average latency in seconds for all\n\
# received packets, including very old ones.\n\
float32 average_latency_all\n\
\n\
================================================================================\n\
MSG: std_msgs/Header\n\
# Standard metadata for higher-level stamped data types.\n\
# This is generally used to communicate timestamped data \n\
# in a particular coordinate frame.\n\
# \n\
# sequence ID: consecutively increasing ID \n\
uint32 seq\n\
#Two-integer timestamp that is expressed as:\n\
# * stamp.secs: seconds (stamp_secs) since epoch\n\
# * stamp.nsecs: nanoseconds since stamp_secs\n\
# time-handling sugar is provided by the client library\n\
time stamp\n\
#Frame this data is associated with\n\
# 0: no frame\n\
# 1: global frame\n\
string frame_id\n\
\n\
";
  }

  static const char* value(const  ::network_monitor_udp::UdpMonitor_<ContainerAllocator> &) { return value(); } 
};

template<class ContainerAllocator> struct HasHeader< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> > : public TrueType {};
template<class ContainerAllocator> struct HasHeader< const ::network_monitor_udp::UdpMonitor_<ContainerAllocator> > : public TrueType {};
} // namespace message_traits
} // namespace ros

namespace ros
{
namespace serialization
{

template<class ContainerAllocator> struct Serializer< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> >
{
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
  {
    stream.next(m.header);
    stream.next(m.server_host);
    stream.next(m.server_port);
    stream.next(m.source_interface);
    stream.next(m.packet_rate);
    stream.next(m.packet_size);
    stream.next(m.latency_bin_limits);
    stream.next(m.latency_bin_values);
    stream.next(m.average_latency_fresh);
    stream.next(m.loss_fresh);
    stream.next(m.average_latency_all);
  }

  ROS_DECLARE_ALLINONE_SERIALIZER;
}; // struct UdpMonitor_
} // namespace serialization
} // namespace ros

namespace ros
{
namespace message_operations
{

template<class ContainerAllocator>
struct Printer< ::network_monitor_udp::UdpMonitor_<ContainerAllocator> >
{
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::network_monitor_udp::UdpMonitor_<ContainerAllocator> & v) 
  {
    s << indent << "header: ";
s << std::endl;
    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
    s << indent << "server_host: ";
    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.server_host);
    s << indent << "server_port: ";
    Printer<uint32_t>::stream(s, indent + "  ", v.server_port);
    s << indent << "source_interface: ";
    Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + "  ", v.source_interface);
    s << indent << "packet_rate: ";
    Printer<float>::stream(s, indent + "  ", v.packet_rate);
    s << indent << "packet_size: ";
    Printer<uint32_t>::stream(s, indent + "  ", v.packet_size);
    s << indent << "latency_bin_limits[]" << std::endl;
    for (size_t i = 0; i < v.latency_bin_limits.size(); ++i)
    {
      s << indent << "  latency_bin_limits[" << i << "]: ";
      Printer<float>::stream(s, indent + "  ", v.latency_bin_limits[i]);
    }
    s << indent << "latency_bin_values[]" << std::endl;
    for (size_t i = 0; i < v.latency_bin_values.size(); ++i)
    {
      s << indent << "  latency_bin_values[" << i << "]: ";
      Printer<float>::stream(s, indent + "  ", v.latency_bin_values[i]);
    }
    s << indent << "average_latency_fresh: ";
    Printer<float>::stream(s, indent + "  ", v.average_latency_fresh);
    s << indent << "loss_fresh: ";
    Printer<float>::stream(s, indent + "  ", v.loss_fresh);
    s << indent << "average_latency_all: ";
    Printer<float>::stream(s, indent + "  ", v.average_latency_all);
  }
};


} // namespace message_operations
} // namespace ros

#endif // NETWORK_MONITOR_UDP_MESSAGE_UDPMONITOR_H

---

network_monitor_udp
Author(s): Blaise Gassend
autogenerated on Fri Jan 11 09:42:46 2013