RIQHandState.h

Go to the documentation of this file.

/* Auto-generated by genmsg_cpp for file /home/rosbuild/hudson/workspace/doc-groovy-riq_hand/doc_stacks/2014-04-22_19-40-45.745981/riq_hand/riq_msgs/msg/RIQHandState.msg */
#ifndef RIQ_MSGS_MESSAGE_RIQHANDSTATE_H
#define RIQ_MSGS_MESSAGE_RIQHANDSTATE_H
#include <string>
#include <vector>
#include <map>
#include <ostream>
#include "ros/serialization.h"
#include "ros/builtin_message_traits.h"
#include "ros/message_operations.h"
#include "ros/time.h"

#include "ros/macros.h"

#include "ros/assert.h"

#include "riq_msgs/RIQActuatorState.h"
#include "riq_msgs/RIQActuatorState.h"
#include "riq_msgs/RIQActuatorState.h"
#include "riq_msgs/RIQActuatorState.h"

namespace riq_msgs
{
template <class ContainerAllocator>
struct RIQHandState_ {
  typedef RIQHandState_<ContainerAllocator> Type;

  RIQHandState_()
  : operational(false)
  , status(0)
  , mode(0)
  , grip(0)
  , object(0)
  , thumb()
  , right_finger()
  , left_finger()
  , scissors()
  {
  }

  RIQHandState_(const ContainerAllocator& _alloc)
  : operational(false)
  , status(0)
  , mode(0)
  , grip(0)
  , object(0)
  , thumb(_alloc)
  , right_finger(_alloc)
  , left_finger(_alloc)
  , scissors(_alloc)
  {
  }

  typedef uint8_t _operational_type;
  uint8_t operational;

  typedef int8_t _status_type;
  int8_t status;

  typedef int8_t _mode_type;
  int8_t mode;

  typedef int8_t _grip_type;
  int8_t grip;

  typedef int8_t _object_type;
  int8_t object;

  typedef  ::riq_msgs::RIQActuatorState_<ContainerAllocator>  _thumb_type;
   ::riq_msgs::RIQActuatorState_<ContainerAllocator>  thumb;

  typedef  ::riq_msgs::RIQActuatorState_<ContainerAllocator>  _right_finger_type;
   ::riq_msgs::RIQActuatorState_<ContainerAllocator>  right_finger;

  typedef  ::riq_msgs::RIQActuatorState_<ContainerAllocator>  _left_finger_type;
   ::riq_msgs::RIQActuatorState_<ContainerAllocator>  left_finger;

  typedef  ::riq_msgs::RIQActuatorState_<ContainerAllocator>  _scissors_type;
   ::riq_msgs::RIQActuatorState_<ContainerAllocator>  scissors;

  enum { FAULTED = 0 };
  enum { IN_PROGRESS = 1 };
  enum { ILLEGAL_OR_UNDEFINED = 2 };
  enum { SUCCESSFUL = 3 };
  enum { CYLINDRICAL = 0 };
  enum { PINCH = 1 };
  enum { SPHERIOD = 2 };
  enum { SCISSORS = 3 };
  enum { STOPPED = 0 };
  enum { OPENED = 1 };
  enum { CLOSED = 2 };
  enum { INITIALIZING_OR_CHANGING = 3 };
  enum { NOT_DETECTED = 0 };
  enum { DETECTED_1_FINGER = 1 };
  enum { DETECTED_2_FINGERS = 2 };
  enum { DETECTED_ALL_FINGERS = 3 };

  typedef boost::shared_ptr< ::riq_msgs::RIQHandState_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::riq_msgs::RIQHandState_<ContainerAllocator>  const> ConstPtr;
  boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
}; // struct RIQHandState
typedef  ::riq_msgs::RIQHandState_<std::allocator<void> > RIQHandState;

typedef boost::shared_ptr< ::riq_msgs::RIQHandState> RIQHandStatePtr;
typedef boost::shared_ptr< ::riq_msgs::RIQHandState const> RIQHandStateConstPtr;


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

} // namespace riq_msgs

namespace ros
{
namespace message_traits
{
template<class ContainerAllocator> struct IsMessage< ::riq_msgs::RIQHandState_<ContainerAllocator> > : public TrueType {};
template<class ContainerAllocator> struct IsMessage< ::riq_msgs::RIQHandState_<ContainerAllocator>  const> : public TrueType {};
template<class ContainerAllocator>
struct MD5Sum< ::riq_msgs::RIQHandState_<ContainerAllocator> > {
  static const char* value() 
  {
    return "3ab70f8c0e9b67b0db99e45af2360afc";
  }

  static const char* value(const  ::riq_msgs::RIQHandState_<ContainerAllocator> &) { return value(); } 
  static const uint64_t static_value1 = 0x3ab70f8c0e9b67b0ULL;
  static const uint64_t static_value2 = 0xdb99e45af2360afcULL;
};

template<class ContainerAllocator>
struct DataType< ::riq_msgs::RIQHandState_<ContainerAllocator> > {
  static const char* value() 
  {
    return "riq_msgs/RIQHandState";
  }

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

template<class ContainerAllocator>
struct Definition< ::riq_msgs::RIQHandState_<ContainerAllocator> > {
  static const char* value() 
  {
    return "# ROS state information from RobotIQ hand\n\
\n\
# Action status\n\
int8 FAULTED              = 0\n\
int8 IN_PROGRESS          = 1\n\
int8 ILLEGAL_OR_UNDEFINED = 2\n\
int8 SUCCESSFUL           = 3\n\
\n\
# Mode constants\n\
int8 CYLINDRICAL = 0\n\
int8 PINCH       = 1\n\
int8 SPHERIOD    = 2\n\
int8 SCISSORS    = 3\n\
\n\
# Grip\n\
int8 STOPPED   = 0\n\
int8 OPENED    = 1\n\
int8 CLOSED    = 2\n\
int8 INITIALIZING_OR_CHANGING = 3\n\
\n\
# Object detection status\n\
int8 NOT_DETECTED         = 0\n\
int8 DETECTED_1_FINGER    = 1\n\
int8 DETECTED_2_FINGERS   = 2\n\
int8 DETECTED_ALL_FINGERS = 3\n\
\n\
\n\
bool    operational  # True when RIQ hand is operational, \n\
                     # False if there is an error, or hand has not been initialized\n\
\n\
int8    status       # Result of last requested action\n\
                     #  SUCCESSFULL, FAULTED, IN_PROGRESS, ILLEGAL_OR_UNDEFINED\n\
\n\
int8    mode         # Mode gripper is curretly in:     \n\
                     #  PINCH, CYLINDRICAL, SPHERIOD, SCISSORS \n\
\n\
int8    grip         # Grip\n\
                     #  CLOSED, OPEN, STOPPED, INTIALIZING_OR_CHANGING\n\
\n\
int8    object       # Object detection\n\
                     #  NOT_DETECTED, DETECTED_1_FINGER, DETECTED_2_FINGERS, DETECTED_ALL_FINGERS\n\
\n\
RIQActuatorState thumb\n\
RIQActuatorState right_finger\n\
RIQActuatorState left_finger\n\
RIQActuatorState scissors      # Scissors is joint motor between right and left finger\n\
================================================================================\n\
MSG: riq_msgs/RIQActuatorState\n\
# ROS state information for RobotIQ actuator.\n\
\n\
# Measured motor current (in Amps)\n\
float64 current\n\
\n\
# Motor position range from (0.0 to 1.0)\n\
float64 position\n\
\n\
# True when finger / actuator detected an object\n\
bool object_detected\n\
";
  }

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

template<class ContainerAllocator> struct IsFixedSize< ::riq_msgs::RIQHandState_<ContainerAllocator> > : public TrueType {};
} // namespace message_traits
} // namespace ros

namespace ros
{
namespace serialization
{

template<class ContainerAllocator> struct Serializer< ::riq_msgs::RIQHandState_<ContainerAllocator> >
{
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
  {
    stream.next(m.operational);
    stream.next(m.status);
    stream.next(m.mode);
    stream.next(m.grip);
    stream.next(m.object);
    stream.next(m.thumb);
    stream.next(m.right_finger);
    stream.next(m.left_finger);
    stream.next(m.scissors);
  }

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

namespace ros
{
namespace message_operations
{

template<class ContainerAllocator>
struct Printer< ::riq_msgs::RIQHandState_<ContainerAllocator> >
{
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::riq_msgs::RIQHandState_<ContainerAllocator> & v) 
  {
    s << indent << "operational: ";
    Printer<uint8_t>::stream(s, indent + "  ", v.operational);
    s << indent << "status: ";
    Printer<int8_t>::stream(s, indent + "  ", v.status);
    s << indent << "mode: ";
    Printer<int8_t>::stream(s, indent + "  ", v.mode);
    s << indent << "grip: ";
    Printer<int8_t>::stream(s, indent + "  ", v.grip);
    s << indent << "object: ";
    Printer<int8_t>::stream(s, indent + "  ", v.object);
    s << indent << "thumb: ";
s << std::endl;
    Printer< ::riq_msgs::RIQActuatorState_<ContainerAllocator> >::stream(s, indent + "  ", v.thumb);
    s << indent << "right_finger: ";
s << std::endl;
    Printer< ::riq_msgs::RIQActuatorState_<ContainerAllocator> >::stream(s, indent + "  ", v.right_finger);
    s << indent << "left_finger: ";
s << std::endl;
    Printer< ::riq_msgs::RIQActuatorState_<ContainerAllocator> >::stream(s, indent + "  ", v.left_finger);
    s << indent << "scissors: ";
s << std::endl;
    Printer< ::riq_msgs::RIQActuatorState_<ContainerAllocator> >::stream(s, indent + "  ", v.scissors);
  }
};


} // namespace message_operations
} // namespace ros

#endif // RIQ_MSGS_MESSAGE_RIQHANDSTATE_H