cop_feedback.h

Go to the documentation of this file.

/* Auto-generated by genmsg_cpp for file /tmp/buildd/ros-diamondback-ias-common-0.1.2/debian/ros-diamondback-ias-common/opt/ros/diamondback/stacks/ias_common/vision_msgs/msg/cop_feedback.msg */
#ifndef VISION_MSGS_MESSAGE_COP_FEEDBACK_H
#define VISION_MSGS_MESSAGE_COP_FEEDBACK_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 "vision_msgs/system_error.h"

namespace vision_msgs
{
template <class ContainerAllocator>
struct cop_feedback_ : public ros::Message
{
  typedef cop_feedback_<ContainerAllocator> Type;

  cop_feedback_()
  : perception_primitive(0)
  , evaluation(0.0)
  , error()
  , eval_whitelist()
  {
  }

  cop_feedback_(const ContainerAllocator& _alloc)
  : perception_primitive(0)
  , evaluation(0.0)
  , error(_alloc)
  , eval_whitelist(_alloc)
  {
  }

  typedef uint64_t _perception_primitive_type;
  uint64_t perception_primitive;

  typedef double _evaluation_type;
  double evaluation;

  typedef std::vector< ::vision_msgs::system_error_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::vision_msgs::system_error_<ContainerAllocator> >::other >  _error_type;
  std::vector< ::vision_msgs::system_error_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::vision_msgs::system_error_<ContainerAllocator> >::other >  error;

  typedef std::vector<uint64_t, typename ContainerAllocator::template rebind<uint64_t>::other >  _eval_whitelist_type;
  std::vector<uint64_t, typename ContainerAllocator::template rebind<uint64_t>::other >  eval_whitelist;


  ROS_DEPRECATED uint32_t get_error_size() const { return (uint32_t)error.size(); }
  ROS_DEPRECATED void set_error_size(uint32_t size) { error.resize((size_t)size); }
  ROS_DEPRECATED void get_error_vec(std::vector< ::vision_msgs::system_error_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::vision_msgs::system_error_<ContainerAllocator> >::other > & vec) const { vec = this->error; }
  ROS_DEPRECATED void set_error_vec(const std::vector< ::vision_msgs::system_error_<ContainerAllocator> , typename ContainerAllocator::template rebind< ::vision_msgs::system_error_<ContainerAllocator> >::other > & vec) { this->error = vec; }
  ROS_DEPRECATED uint32_t get_eval_whitelist_size() const { return (uint32_t)eval_whitelist.size(); }
  ROS_DEPRECATED void set_eval_whitelist_size(uint32_t size) { eval_whitelist.resize((size_t)size); }
  ROS_DEPRECATED void get_eval_whitelist_vec(std::vector<uint64_t, typename ContainerAllocator::template rebind<uint64_t>::other > & vec) const { vec = this->eval_whitelist; }
  ROS_DEPRECATED void set_eval_whitelist_vec(const std::vector<uint64_t, typename ContainerAllocator::template rebind<uint64_t>::other > & vec) { this->eval_whitelist = vec; }
private:
  static const char* __s_getDataType_() { return "vision_msgs/cop_feedback"; }
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 "e876bab42e04aea08a659bc18c7b47cc"; }
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 "#Message that cop uses to  answer on specified topics, U. Klank klank@in.tum.de\n\
uint64         perception_primitive         # Perception primitive that caused this answer\n\
float64        evaluation                   # A score describing the quality of the outcomes of the perception primitive\n\
system_error[] error                        # A list of occured system failures which might be caused by the perception primitive\n\
uint64[]       eval_whitelist               # list results which are included into the evaluation (note: default is all, not none, so an empty list means that all elements have to be evaluated, since the case that none of the results should get an evaluation does not make much sense)\n\
\n\
================================================================================\n\
MSG: vision_msgs/system_error\n\
uint64 MANIPULATION_POSE_UNREACHABLE = 64\n\
uint64 GRASP_FAILED = 128  # Grasp into the void\n\
uint64 OBJECT_NOT_FOUND = 256\n\
uint64 VISION_PRIMITIVE_FAILED = 512\n\
uint64 CONTRADICTING_TACTILE_FEEDBACK = 1024  # Collide without expecting it\n\
uint64 CONTRADICTING_VISION_RESULTS = 2048\n\
uint64 GRASP_FAILED_AND_CRASHED = 4096  # Throwing something out of the way\n\
uint64 JLO_ERROR = 8192  # Could not get position\n\
uint64 VECTOR_FIELD_CANT_REACH = 16384  # The arm got stuck along the way, did not reach the final grasping pose\n\
\n\
uint64  error_id                # One of the error constants defined above\n\
string  node_name               # The node causing this error\n\
string  error_description       # Further information about the error\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, perception_primitive);
    ros::serialization::serialize(stream, evaluation);
    ros::serialization::serialize(stream, error);
    ros::serialization::serialize(stream, eval_whitelist);
    return stream.getData();
  }

  ROS_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
  {
    ros::serialization::IStream stream(read_ptr, 1000000000);
    ros::serialization::deserialize(stream, perception_primitive);
    ros::serialization::deserialize(stream, evaluation);
    ros::serialization::deserialize(stream, error);
    ros::serialization::deserialize(stream, eval_whitelist);
    return stream.getData();
  }

  ROS_DEPRECATED virtual uint32_t serializationLength() const
  {
    uint32_t size = 0;
    size += ros::serialization::serializationLength(perception_primitive);
    size += ros::serialization::serializationLength(evaluation);
    size += ros::serialization::serializationLength(error);
    size += ros::serialization::serializationLength(eval_whitelist);
    return size;
  }

  typedef boost::shared_ptr< ::vision_msgs::cop_feedback_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::vision_msgs::cop_feedback_<ContainerAllocator>  const> ConstPtr;
}; // struct cop_feedback
typedef  ::vision_msgs::cop_feedback_<std::allocator<void> > cop_feedback;

typedef boost::shared_ptr< ::vision_msgs::cop_feedback> cop_feedbackPtr;
typedef boost::shared_ptr< ::vision_msgs::cop_feedback const> cop_feedbackConstPtr;


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

} // namespace vision_msgs

namespace ros
{
namespace message_traits
{
template<class ContainerAllocator>
struct MD5Sum< ::vision_msgs::cop_feedback_<ContainerAllocator> > {
  static const char* value() 
  {
    return "e876bab42e04aea08a659bc18c7b47cc";
  }

  static const char* value(const  ::vision_msgs::cop_feedback_<ContainerAllocator> &) { return value(); } 
  static const uint64_t static_value1 = 0xe876bab42e04aea0ULL;
  static const uint64_t static_value2 = 0x8a659bc18c7b47ccULL;
};

template<class ContainerAllocator>
struct DataType< ::vision_msgs::cop_feedback_<ContainerAllocator> > {
  static const char* value() 
  {
    return "vision_msgs/cop_feedback";
  }

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

template<class ContainerAllocator>
struct Definition< ::vision_msgs::cop_feedback_<ContainerAllocator> > {
  static const char* value() 
  {
    return "#Message that cop uses to  answer on specified topics, U. Klank klank@in.tum.de\n\
uint64         perception_primitive         # Perception primitive that caused this answer\n\
float64        evaluation                   # A score describing the quality of the outcomes of the perception primitive\n\
system_error[] error                        # A list of occured system failures which might be caused by the perception primitive\n\
uint64[]       eval_whitelist               # list results which are included into the evaluation (note: default is all, not none, so an empty list means that all elements have to be evaluated, since the case that none of the results should get an evaluation does not make much sense)\n\
\n\
================================================================================\n\
MSG: vision_msgs/system_error\n\
uint64 MANIPULATION_POSE_UNREACHABLE = 64\n\
uint64 GRASP_FAILED = 128  # Grasp into the void\n\
uint64 OBJECT_NOT_FOUND = 256\n\
uint64 VISION_PRIMITIVE_FAILED = 512\n\
uint64 CONTRADICTING_TACTILE_FEEDBACK = 1024  # Collide without expecting it\n\
uint64 CONTRADICTING_VISION_RESULTS = 2048\n\
uint64 GRASP_FAILED_AND_CRASHED = 4096  # Throwing something out of the way\n\
uint64 JLO_ERROR = 8192  # Could not get position\n\
uint64 VECTOR_FIELD_CANT_REACH = 16384  # The arm got stuck along the way, did not reach the final grasping pose\n\
\n\
uint64  error_id                # One of the error constants defined above\n\
string  node_name               # The node causing this error\n\
string  error_description       # Further information about the error\n\
\n\
";
  }

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

} // namespace message_traits
} // namespace ros

namespace ros
{
namespace serialization
{

template<class ContainerAllocator> struct Serializer< ::vision_msgs::cop_feedback_<ContainerAllocator> >
{
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
  {
    stream.next(m.perception_primitive);
    stream.next(m.evaluation);
    stream.next(m.error);
    stream.next(m.eval_whitelist);
  }

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

namespace ros
{
namespace message_operations
{

template<class ContainerAllocator>
struct Printer< ::vision_msgs::cop_feedback_<ContainerAllocator> >
{
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::vision_msgs::cop_feedback_<ContainerAllocator> & v) 
  {
    s << indent << "perception_primitive: ";
    Printer<uint64_t>::stream(s, indent + "  ", v.perception_primitive);
    s << indent << "evaluation: ";
    Printer<double>::stream(s, indent + "  ", v.evaluation);
    s << indent << "error[]" << std::endl;
    for (size_t i = 0; i < v.error.size(); ++i)
    {
      s << indent << "  error[" << i << "]: ";
      s << std::endl;
      s << indent;
      Printer< ::vision_msgs::system_error_<ContainerAllocator> >::stream(s, indent + "    ", v.error[i]);
    }
    s << indent << "eval_whitelist[]" << std::endl;
    for (size_t i = 0; i < v.eval_whitelist.size(); ++i)
    {
      s << indent << "  eval_whitelist[" << i << "]: ";
      Printer<uint64_t>::stream(s, indent + "  ", v.eval_whitelist[i]);
    }
  }
};


} // namespace message_operations
} // namespace ros

#endif // VISION_MSGS_MESSAGE_COP_FEEDBACK_H

---

vision_msgs
Author(s): Ulrich F Klank
autogenerated on Fri Jan 11 09:59:27 2013