env_set.h

Go to the documentation of this file.

/* Auto-generated by genmsg_cpp for file /home/rosbuild/hudson/workspace/doc-fuerte-jsk-ros-pkg/doc_stacks/2013-03-23_12-16-27.483192/jsk-ros-pkg/openrave_planning/openraveros/srv/env_set.srv */
#ifndef OPENRAVEROS_SERVICE_ENV_SET_H
#define OPENRAVEROS_SERVICE_ENV_SET_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 "ros/service_traits.h"




namespace openraveros
{
template <class ContainerAllocator>
struct env_setRequest_ {
  typedef env_setRequest_<ContainerAllocator> Type;

  env_setRequest_()
  : setmask(0)
  , sim_action(0)
  , sim_timestep(0.0)
  , physicsengine()
  , collisionchecker()
  , viewer()
  , viewerwidth(0)
  , viewerheight(0)
  , gravity()
  , debuglevel()
  {
    gravity.assign(0.0);
  }

  env_setRequest_(const ContainerAllocator& _alloc)
  : setmask(0)
  , sim_action(0)
  , sim_timestep(0.0)
  , physicsengine(_alloc)
  , collisionchecker(_alloc)
  , viewer(_alloc)
  , viewerwidth(0)
  , viewerheight(0)
  , gravity()
  , debuglevel(_alloc)
  {
    gravity.assign(0.0);
  }

  typedef uint32_t _setmask_type;
  uint32_t setmask;

  typedef uint8_t _sim_action_type;
  uint8_t sim_action;

  typedef float _sim_timestep_type;
  float sim_timestep;

  typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _physicsengine_type;
  std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  physicsengine;

  typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _collisionchecker_type;
  std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  collisionchecker;

  typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _viewer_type;
  std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  viewer;

  typedef int32_t _viewerwidth_type;
  int32_t viewerwidth;

  typedef int32_t _viewerheight_type;
  int32_t viewerheight;

  typedef boost::array<float, 3>  _gravity_type;
  boost::array<float, 3>  gravity;

  typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  _debuglevel_type;
  std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other >  debuglevel;

  enum { Set_Simulation = 1 };
  enum { Set_PhysicsEngine = 2 };
  enum { Set_CollisionChecker = 4 };
  enum { Set_Gravity = 8 };
  enum { Set_DebugLevel = 32 };
  enum { Set_Viewer = 64 };
  enum { Set_ViewerDims = 128 };
  enum { SimAction_Start = 1 };
  enum { SimAction_Stop = 2 };
  enum { SimAction_Timestep = 3 };

  typedef boost::shared_ptr< ::openraveros::env_setRequest_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::openraveros::env_setRequest_<ContainerAllocator>  const> ConstPtr;
  boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
}; // struct env_setRequest
typedef  ::openraveros::env_setRequest_<std::allocator<void> > env_setRequest;

typedef boost::shared_ptr< ::openraveros::env_setRequest> env_setRequestPtr;
typedef boost::shared_ptr< ::openraveros::env_setRequest const> env_setRequestConstPtr;


template <class ContainerAllocator>
struct env_setResponse_ {
  typedef env_setResponse_<ContainerAllocator> Type;

  env_setResponse_()
  {
  }

  env_setResponse_(const ContainerAllocator& _alloc)
  {
  }


  typedef boost::shared_ptr< ::openraveros::env_setResponse_<ContainerAllocator> > Ptr;
  typedef boost::shared_ptr< ::openraveros::env_setResponse_<ContainerAllocator>  const> ConstPtr;
  boost::shared_ptr<std::map<std::string, std::string> > __connection_header;
}; // struct env_setResponse
typedef  ::openraveros::env_setResponse_<std::allocator<void> > env_setResponse;

typedef boost::shared_ptr< ::openraveros::env_setResponse> env_setResponsePtr;
typedef boost::shared_ptr< ::openraveros::env_setResponse const> env_setResponseConstPtr;

struct env_set
{

typedef env_setRequest Request;
typedef env_setResponse Response;
Request request;
Response response;

typedef Request RequestType;
typedef Response ResponseType;
}; // struct env_set
} // namespace openraveros

namespace ros
{
namespace message_traits
{
template<class ContainerAllocator> struct IsMessage< ::openraveros::env_setRequest_<ContainerAllocator> > : public TrueType {};
template<class ContainerAllocator> struct IsMessage< ::openraveros::env_setRequest_<ContainerAllocator>  const> : public TrueType {};
template<class ContainerAllocator>
struct MD5Sum< ::openraveros::env_setRequest_<ContainerAllocator> > {
  static const char* value() 
  {
    return "912134b9acb15f89f82428a80c7617cf";
  }

  static const char* value(const  ::openraveros::env_setRequest_<ContainerAllocator> &) { return value(); } 
  static const uint64_t static_value1 = 0x912134b9acb15f89ULL;
  static const uint64_t static_value2 = 0xf82428a80c7617cfULL;
};

template<class ContainerAllocator>
struct DataType< ::openraveros::env_setRequest_<ContainerAllocator> > {
  static const char* value() 
  {
    return "openraveros/env_setRequest";
  }

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

template<class ContainerAllocator>
struct Definition< ::openraveros::env_setRequest_<ContainerAllocator> > {
  static const char* value() 
  {
    return "\n\
\n\
uint32 setmask\n\
uint32 Set_Simulation=1\n\
uint32 Set_PhysicsEngine=2\n\
uint32 Set_CollisionChecker=4\n\
uint32 Set_Gravity=8\n\
uint32 Set_DebugLevel=32\n\
uint32 Set_Viewer=64\n\
uint32 Set_ViewerDims=128\n\
\n\
\n\
uint8 sim_action\n\
uint8 SimAction_Start=1\n\
uint8 SimAction_Stop=2\n\
uint8 SimAction_Timestep=3\n\
float32 sim_timestep\n\
\n\
string physicsengine\n\
string collisionchecker\n\
string viewer\n\
int32 viewerwidth\n\
int32 viewerheight\n\
float32[3] gravity\n\
string debuglevel\n\
\n\
";
  }

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

} // namespace message_traits
} // namespace ros


namespace ros
{
namespace message_traits
{
template<class ContainerAllocator> struct IsMessage< ::openraveros::env_setResponse_<ContainerAllocator> > : public TrueType {};
template<class ContainerAllocator> struct IsMessage< ::openraveros::env_setResponse_<ContainerAllocator>  const> : public TrueType {};
template<class ContainerAllocator>
struct MD5Sum< ::openraveros::env_setResponse_<ContainerAllocator> > {
  static const char* value() 
  {
    return "d41d8cd98f00b204e9800998ecf8427e";
  }

  static const char* value(const  ::openraveros::env_setResponse_<ContainerAllocator> &) { return value(); } 
  static const uint64_t static_value1 = 0xd41d8cd98f00b204ULL;
  static const uint64_t static_value2 = 0xe9800998ecf8427eULL;
};

template<class ContainerAllocator>
struct DataType< ::openraveros::env_setResponse_<ContainerAllocator> > {
  static const char* value() 
  {
    return "openraveros/env_setResponse";
  }

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

template<class ContainerAllocator>
struct Definition< ::openraveros::env_setResponse_<ContainerAllocator> > {
  static const char* value() 
  {
    return "\n\
\n\
";
  }

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

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

namespace ros
{
namespace serialization
{

template<class ContainerAllocator> struct Serializer< ::openraveros::env_setRequest_<ContainerAllocator> >
{
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
  {
    stream.next(m.setmask);
    stream.next(m.sim_action);
    stream.next(m.sim_timestep);
    stream.next(m.physicsengine);
    stream.next(m.collisionchecker);
    stream.next(m.viewer);
    stream.next(m.viewerwidth);
    stream.next(m.viewerheight);
    stream.next(m.gravity);
    stream.next(m.debuglevel);
  }

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


namespace ros
{
namespace serialization
{

template<class ContainerAllocator> struct Serializer< ::openraveros::env_setResponse_<ContainerAllocator> >
{
  template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
  {
  }

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

namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum<openraveros::env_set> {
  static const char* value() 
  {
    return "912134b9acb15f89f82428a80c7617cf";
  }

  static const char* value(const openraveros::env_set&) { return value(); } 
};

template<>
struct DataType<openraveros::env_set> {
  static const char* value() 
  {
    return "openraveros/env_set";
  }

  static const char* value(const openraveros::env_set&) { return value(); } 
};

template<class ContainerAllocator>
struct MD5Sum<openraveros::env_setRequest_<ContainerAllocator> > {
  static const char* value() 
  {
    return "912134b9acb15f89f82428a80c7617cf";
  }

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

template<class ContainerAllocator>
struct DataType<openraveros::env_setRequest_<ContainerAllocator> > {
  static const char* value() 
  {
    return "openraveros/env_set";
  }

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

template<class ContainerAllocator>
struct MD5Sum<openraveros::env_setResponse_<ContainerAllocator> > {
  static const char* value() 
  {
    return "912134b9acb15f89f82428a80c7617cf";
  }

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

template<class ContainerAllocator>
struct DataType<openraveros::env_setResponse_<ContainerAllocator> > {
  static const char* value() 
  {
    return "openraveros/env_set";
  }

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

} // namespace service_traits
} // namespace ros

#endif // OPENRAVEROS_SERVICE_ENV_SET_H