MpcDynFormattedData.h

Go to the documentation of this file.

/* Auto-generated by genmsg_cpp for file /home/rosbuild/hudson/workspace/doc-fuerte-gt-ros-pkg/doc_stacks/2013-11-27_11-23-35.692702/hrl-haptic-manip/hrl_haptic_manipulation_in_clutter_msgs/msg/MpcDynFormattedData.msg */
#ifndef HRL_HAPTIC_MANIPULATION_IN_CLUTTER_MSGS_MESSAGE_MPCDYNFORMATTEDDATA_H
#define HRL_HAPTIC_MANIPULATION_IN_CLUTTER_MSGS_MESSAGE_MPCDYNFORMATTEDDATA_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 "std_msgs/Header.h"

namespace hrl_haptic_manipulation_in_clutter_msgs
{
template <class ContainerAllocator>
struct MpcDynFormattedData_ {
  typedef MpcDynFormattedData_<ContainerAllocator> Type;

  MpcDynFormattedData_()
  : header()
  , alpha(0.0)
  , delta_x_d()
  , A_tl()
  , A_tr()
  , A_bl()
  , A_br()
  , B_tl()
  , B_tr()
  , B_bl()
  , B_br()
  , qd_max()
  , u_max()
  , q_min()
  , q_max()
  , delta_f_max()
  , n_K_J_all()
  , all_J_T_K_J()
  , J()
  , f_max_delta_t()
  , mass_n_J_com()
  , Kp()
  , Kd()
  , q_des_cur_0()
  , qd_0()
  , q_0()
  , tau_cont_sum_0()
  {
  }

  MpcDynFormattedData_(const ContainerAllocator& _alloc)
  : header(_alloc)
  , alpha(0.0)
  , delta_x_d(_alloc)
  , A_tl(_alloc)
  , A_tr(_alloc)
  , A_bl(_alloc)
  , A_br(_alloc)
  , B_tl(_alloc)
  , B_tr(_alloc)
  , B_bl(_alloc)
  , B_br(_alloc)
  , qd_max(_alloc)
  , u_max(_alloc)
  , q_min(_alloc)
  , q_max(_alloc)
  , delta_f_max(_alloc)
  , n_K_J_all(_alloc)
  , all_J_T_K_J(_alloc)
  , J(_alloc)
  , f_max_delta_t(_alloc)
  , mass_n_J_com(_alloc)
  , Kp(_alloc)
  , Kd(_alloc)
  , q_des_cur_0(_alloc)
  , qd_0(_alloc)
  , q_0(_alloc)
  , tau_cont_sum_0(_alloc)
  {
  }

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

  typedef double _alpha_type;
  double alpha;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _delta_x_d_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  delta_x_d;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _A_tl_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  A_tl;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _A_tr_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  A_tr;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _A_bl_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  A_bl;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _A_br_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  A_br;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _B_tl_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  B_tl;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _B_tr_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  B_tr;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _B_bl_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  B_bl;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _B_br_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  B_br;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _qd_max_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  qd_max;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _u_max_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  u_max;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _q_min_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  q_min;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _q_max_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  q_max;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _delta_f_max_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  delta_f_max;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _n_K_J_all_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  n_K_J_all;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _all_J_T_K_J_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  all_J_T_K_J;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _J_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  J;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _f_max_delta_t_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  f_max_delta_t;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _mass_n_J_com_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  mass_n_J_com;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _Kp_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  Kp;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _Kd_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  Kd;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _q_des_cur_0_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  q_des_cur_0;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _qd_0_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  qd_0;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _q_0_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  q_0;

  typedef std::vector<double, typename ContainerAllocator::template rebind<double>::other >  _tau_cont_sum_0_type;
  std::vector<double, typename ContainerAllocator::template rebind<double>::other >  tau_cont_sum_0;


  typedef boost::shared_ptr< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator>  const> ConstPtr;
  boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
}; // struct MpcDynFormattedData
typedef  ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<std::allocator<void> > MpcDynFormattedData;

typedef boost::shared_ptr< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData> MpcDynFormattedDataPtr;
typedef boost::shared_ptr< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData const> MpcDynFormattedDataConstPtr;


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

} // namespace hrl_haptic_manipulation_in_clutter_msgs

namespace ros
{
namespace message_traits
{
template<class ContainerAllocator> struct IsMessage< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> > : public TrueType {};
template<class ContainerAllocator> struct IsMessage< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator>  const> : public TrueType {};
template<class ContainerAllocator>
struct MD5Sum< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> > {
  static const char* value() 
  {
    return "409d8cadc45ef90a32fdf8e0c0ed4e2d";
  }

  static const char* value(const  ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> &) { return value(); } 
  static const uint64_t static_value1 = 0x409d8cadc45ef90aULL;
  static const uint64_t static_value2 = 0x32fdf8e0c0ed4e2dULL;
};

template<class ContainerAllocator>
struct DataType< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> > {
  static const char* value() 
  {
    return "hrl_haptic_manipulation_in_clutter_msgs/MpcDynFormattedData";
  }

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

template<class ContainerAllocator>
struct Definition< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> > {
  static const char* value() 
  {
    return "\n\
Header header\n\
\n\
float64 alpha\n\
float64[] delta_x_d\n\
float64[] A_tl\n\
float64[] A_tr\n\
float64[] A_bl\n\
float64[] A_br\n\
float64[] B_tl\n\
float64[] B_tr\n\
float64[] B_bl\n\
float64[] B_br\n\
float64[] qd_max\n\
float64[] u_max\n\
float64[] q_min\n\
float64[] q_max\n\
float64[] delta_f_max\n\
float64[] n_K_J_all\n\
float64[] all_J_T_K_J\n\
float64[] J\n\
float64[] f_max_delta_t\n\
float64[] mass_n_J_com\n\
float64[] Kp\n\
float64[] Kd\n\
float64[] q_des_cur_0\n\
float64[] qd_0\n\
float64[] q_0\n\
float64[] tau_cont_sum_0\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  ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> &) { return value(); } 
};

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

namespace ros
{
namespace serialization
{

template<class ContainerAllocator> struct Serializer< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> >
{
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
  {
    stream.next(m.header);
    stream.next(m.alpha);
    stream.next(m.delta_x_d);
    stream.next(m.A_tl);
    stream.next(m.A_tr);
    stream.next(m.A_bl);
    stream.next(m.A_br);
    stream.next(m.B_tl);
    stream.next(m.B_tr);
    stream.next(m.B_bl);
    stream.next(m.B_br);
    stream.next(m.qd_max);
    stream.next(m.u_max);
    stream.next(m.q_min);
    stream.next(m.q_max);
    stream.next(m.delta_f_max);
    stream.next(m.n_K_J_all);
    stream.next(m.all_J_T_K_J);
    stream.next(m.J);
    stream.next(m.f_max_delta_t);
    stream.next(m.mass_n_J_com);
    stream.next(m.Kp);
    stream.next(m.Kd);
    stream.next(m.q_des_cur_0);
    stream.next(m.qd_0);
    stream.next(m.q_0);
    stream.next(m.tau_cont_sum_0);
  }

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

namespace ros
{
namespace message_operations
{

template<class ContainerAllocator>
struct Printer< ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> >
{
  template<typename Stream> static void stream(Stream& s, const std::string& indent, const  ::hrl_haptic_manipulation_in_clutter_msgs::MpcDynFormattedData_<ContainerAllocator> & v) 
  {
    s << indent << "header: ";
s << std::endl;
    Printer< ::std_msgs::Header_<ContainerAllocator> >::stream(s, indent + "  ", v.header);
    s << indent << "alpha: ";
    Printer<double>::stream(s, indent + "  ", v.alpha);
    s << indent << "delta_x_d[]" << std::endl;
    for (size_t i = 0; i < v.delta_x_d.size(); ++i)
    {
      s << indent << "  delta_x_d[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.delta_x_d[i]);
    }
    s << indent << "A_tl[]" << std::endl;
    for (size_t i = 0; i < v.A_tl.size(); ++i)
    {
      s << indent << "  A_tl[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.A_tl[i]);
    }
    s << indent << "A_tr[]" << std::endl;
    for (size_t i = 0; i < v.A_tr.size(); ++i)
    {
      s << indent << "  A_tr[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.A_tr[i]);
    }
    s << indent << "A_bl[]" << std::endl;
    for (size_t i = 0; i < v.A_bl.size(); ++i)
    {
      s << indent << "  A_bl[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.A_bl[i]);
    }
    s << indent << "A_br[]" << std::endl;
    for (size_t i = 0; i < v.A_br.size(); ++i)
    {
      s << indent << "  A_br[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.A_br[i]);
    }
    s << indent << "B_tl[]" << std::endl;
    for (size_t i = 0; i < v.B_tl.size(); ++i)
    {
      s << indent << "  B_tl[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.B_tl[i]);
    }
    s << indent << "B_tr[]" << std::endl;
    for (size_t i = 0; i < v.B_tr.size(); ++i)
    {
      s << indent << "  B_tr[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.B_tr[i]);
    }
    s << indent << "B_bl[]" << std::endl;
    for (size_t i = 0; i < v.B_bl.size(); ++i)
    {
      s << indent << "  B_bl[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.B_bl[i]);
    }
    s << indent << "B_br[]" << std::endl;
    for (size_t i = 0; i < v.B_br.size(); ++i)
    {
      s << indent << "  B_br[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.B_br[i]);
    }
    s << indent << "qd_max[]" << std::endl;
    for (size_t i = 0; i < v.qd_max.size(); ++i)
    {
      s << indent << "  qd_max[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.qd_max[i]);
    }
    s << indent << "u_max[]" << std::endl;
    for (size_t i = 0; i < v.u_max.size(); ++i)
    {
      s << indent << "  u_max[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.u_max[i]);
    }
    s << indent << "q_min[]" << std::endl;
    for (size_t i = 0; i < v.q_min.size(); ++i)
    {
      s << indent << "  q_min[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.q_min[i]);
    }
    s << indent << "q_max[]" << std::endl;
    for (size_t i = 0; i < v.q_max.size(); ++i)
    {
      s << indent << "  q_max[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.q_max[i]);
    }
    s << indent << "delta_f_max[]" << std::endl;
    for (size_t i = 0; i < v.delta_f_max.size(); ++i)
    {
      s << indent << "  delta_f_max[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.delta_f_max[i]);
    }
    s << indent << "n_K_J_all[]" << std::endl;
    for (size_t i = 0; i < v.n_K_J_all.size(); ++i)
    {
      s << indent << "  n_K_J_all[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.n_K_J_all[i]);
    }
    s << indent << "all_J_T_K_J[]" << std::endl;
    for (size_t i = 0; i < v.all_J_T_K_J.size(); ++i)
    {
      s << indent << "  all_J_T_K_J[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.all_J_T_K_J[i]);
    }
    s << indent << "J[]" << std::endl;
    for (size_t i = 0; i < v.J.size(); ++i)
    {
      s << indent << "  J[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.J[i]);
    }
    s << indent << "f_max_delta_t[]" << std::endl;
    for (size_t i = 0; i < v.f_max_delta_t.size(); ++i)
    {
      s << indent << "  f_max_delta_t[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.f_max_delta_t[i]);
    }
    s << indent << "mass_n_J_com[]" << std::endl;
    for (size_t i = 0; i < v.mass_n_J_com.size(); ++i)
    {
      s << indent << "  mass_n_J_com[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.mass_n_J_com[i]);
    }
    s << indent << "Kp[]" << std::endl;
    for (size_t i = 0; i < v.Kp.size(); ++i)
    {
      s << indent << "  Kp[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.Kp[i]);
    }
    s << indent << "Kd[]" << std::endl;
    for (size_t i = 0; i < v.Kd.size(); ++i)
    {
      s << indent << "  Kd[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.Kd[i]);
    }
    s << indent << "q_des_cur_0[]" << std::endl;
    for (size_t i = 0; i < v.q_des_cur_0.size(); ++i)
    {
      s << indent << "  q_des_cur_0[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.q_des_cur_0[i]);
    }
    s << indent << "qd_0[]" << std::endl;
    for (size_t i = 0; i < v.qd_0.size(); ++i)
    {
      s << indent << "  qd_0[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.qd_0[i]);
    }
    s << indent << "q_0[]" << std::endl;
    for (size_t i = 0; i < v.q_0.size(); ++i)
    {
      s << indent << "  q_0[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.q_0[i]);
    }
    s << indent << "tau_cont_sum_0[]" << std::endl;
    for (size_t i = 0; i < v.tau_cont_sum_0.size(); ++i)
    {
      s << indent << "  tau_cont_sum_0[" << i << "]: ";
      Printer<double>::stream(s, indent + "  ", v.tau_cont_sum_0[i]);
    }
  }
};


} // namespace message_operations
} // namespace ros

#endif // HRL_HAPTIC_MANIPULATION_IN_CLUTTER_MSGS_MESSAGE_MPCDYNFORMATTEDDATA_H