Colony » Colony Scout

/* Auto-generated by genmsg_cpp for file /home/jeff/code/scoutos/scout/power/msg/power_state_changed.msg */

#ifndef POWER_MESSAGE_POWER_STATE_CHANGED_H

#define POWER_MESSAGE_POWER_STATE_CHANGED_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 power

{

template <class ContainerAllocator>

struct power_state_changed_ : public ros::Message

{

  typedef power_state_changed_<ContainerAllocator> Type;

  power_state_changed_()

  : header()

  , voltage(0)

  , percentage(0)

  , draw(0)

  , externalpower(false)

  , warning(false)

  , critical(false)

  {

  }

  power_state_changed_(const ContainerAllocator& _alloc)

  : header(_alloc)

  , voltage(0)

  , percentage(0)

  , draw(0)

  , externalpower(false)

  , warning(false)

  , critical(false)

  {

  }

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

   ::std_msgs::Header_<ContainerAllocator>  header;

  typedef uint32_t _voltage_type;

  uint32_t voltage;

  typedef uint32_t _percentage_type;

  uint32_t percentage;

  typedef uint32_t _draw_type;

  uint32_t draw;

  typedef uint8_t _externalpower_type;

  uint8_t externalpower;

  typedef uint8_t _warning_type;

  uint8_t warning;

  typedef uint8_t _critical_type;

  uint8_t critical;

private:

  static const char* __s_getDataType_() { return "power/power_state_changed"; }

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 "fc98f58bb6056947bbbbbad6cc36490a"; }

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\

#32-bit integer with current voltage info\n\

uint32 voltage\n\

#power percentage [0-100]\n\

uint32 percentage\n\

#current draw in mW\n\

uint32 draw\n\

#are we on external power?\n\

bool externalpower\n\

#is the battery at a warning state?\n\

bool warning\n\

#is the battery at a critical state?\n\

bool critical\n\

\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, voltage);

    ros::serialization::serialize(stream, percentage);

    ros::serialization::serialize(stream, draw);

    ros::serialization::serialize(stream, externalpower);

    ros::serialization::serialize(stream, warning);

    ros::serialization::serialize(stream, critical);

    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, voltage);

    ros::serialization::deserialize(stream, percentage);

    ros::serialization::deserialize(stream, draw);

    ros::serialization::deserialize(stream, externalpower);

    ros::serialization::deserialize(stream, warning);

    ros::serialization::deserialize(stream, critical);

    return stream.getData();

  }

  ROS_DEPRECATED virtual uint32_t serializationLength() const

  {

    uint32_t size = 0;

    size += ros::serialization::serializationLength(header);

    size += ros::serialization::serializationLength(voltage);

    size += ros::serialization::serializationLength(percentage);

    size += ros::serialization::serializationLength(draw);

    size += ros::serialization::serializationLength(externalpower);

    size += ros::serialization::serializationLength(warning);

    size += ros::serialization::serializationLength(critical);

    return size;

  }

  typedef boost::shared_ptr< ::power::power_state_changed_<ContainerAllocator> > Ptr;

  typedef boost::shared_ptr< ::power::power_state_changed_<ContainerAllocator>  const> ConstPtr;

}; // struct power_state_changed

typedef  ::power::power_state_changed_<std::allocator<void> > power_state_changed;

typedef boost::shared_ptr< ::power::power_state_changed> power_state_changedPtr;

typedef boost::shared_ptr< ::power::power_state_changed const> power_state_changedConstPtr;

template<typename ContainerAllocator>

std::ostream& operator<<(std::ostream& s, const  ::power::power_state_changed_<ContainerAllocator> & v)

{

  ros::message_operations::Printer< ::power::power_state_changed_<ContainerAllocator> >::stream(s, "", v);

  return s;}

} // namespace power

namespace ros

{

namespace message_traits

{

template<class ContainerAllocator>

struct MD5Sum< ::power::power_state_changed_<ContainerAllocator> > {

  static const char* value() 

  {

    return "fc98f58bb6056947bbbbbad6cc36490a";

  }

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

  static const uint64_t static_value1 = 0xfc98f58bb6056947ULL;

  static const uint64_t static_value2 = 0xbbbbbad6cc36490aULL;

};

template<class ContainerAllocator>

struct DataType< ::power::power_state_changed_<ContainerAllocator> > {

  static const char* value() 

  {

    return "power/power_state_changed";

  }

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

};

template<class ContainerAllocator>

struct Definition< ::power::power_state_changed_<ContainerAllocator> > {

  static const char* value() 

  {

    return "Header header\n\

#32-bit integer with current voltage info\n\

uint32 voltage\n\

#power percentage [0-100]\n\

uint32 percentage\n\

#current draw in mW\n\

uint32 draw\n\

#are we on external power?\n\

bool externalpower\n\

#is the battery at a warning state?\n\

bool warning\n\

#is the battery at a critical state?\n\

bool critical\n\

\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  ::power::power_state_changed_<ContainerAllocator> &) { return value(); } 

};

template<class ContainerAllocator> struct HasHeader< ::power::power_state_changed_<ContainerAllocator> > : public TrueType {};

template<class ContainerAllocator> struct HasHeader< const ::power::power_state_changed_<ContainerAllocator> > : public TrueType {};

} // namespace message_traits

} // namespace ros

namespace ros

{

namespace serialization

{

template<class ContainerAllocator> struct Serializer< ::power::power_state_changed_<ContainerAllocator> >

{

  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)

  {

    stream.next(m.header);

    stream.next(m.voltage);

    stream.next(m.percentage);

    stream.next(m.draw);

    stream.next(m.externalpower);

    stream.next(m.warning);

    stream.next(m.critical);

  }

  ROS_DECLARE_ALLINONE_SERIALIZER;

}; // struct power_state_changed_

} // namespace serialization

} // namespace ros

namespace ros

{

namespace message_operations

{

template<class ContainerAllocator>

struct Printer< ::power::power_state_changed_<ContainerAllocator> >

{

  template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::power::power_state_changed_<ContainerAllocator> & v) 

  {

    s << indent << "header: ";

s << std::endl;

    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);

    s << indent << "voltage: ";

    Printer<uint32_t>::stream(s, indent + "  ", v.voltage);

    s << indent << "percentage: ";

    Printer<uint32_t>::stream(s, indent + "  ", v.percentage);

    s << indent << "draw: ";

    Printer<uint32_t>::stream(s, indent + "  ", v.draw);

    s << indent << "externalpower: ";

    Printer<uint8_t>::stream(s, indent + "  ", v.externalpower);

    s << indent << "warning: ";

    Printer<uint8_t>::stream(s, indent + "  ", v.warning);

    s << indent << "critical: ";

    Printer<uint8_t>::stream(s, indent + "  ", v.critical);

  }

};

} // namespace message_operations

} // namespace ros

#endif // POWER_MESSAGE_POWER_STATE_CHANGED_H