p36850791
/
kinetic-devel
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

roslib: REP 100. Turned off message generation in roslib. Adding auto-generated sources for backwards compatibility

This commit is contained in:
Ken Conley 2010-11-09 08:18:07 +00:00
parent 9eb8379c0b
commit 4706deaa94
8 changed files with 1330 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
core/roslib/CMakeLists.txt
View File

@ -4,7 +4,6 @@ include(CheckIncludeFile)
include(CheckFunctionExists) include(CheckFunctionExists)
include(CheckCXXSourceCompiles) include(CheckCXXSourceCompiles)
rosbuild_init() rosbuild_init()
rosbuild_genmsg()
# To get system info used in time library # To get system info used in time library
CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h) CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/config.h.in ${CMAKE_CURRENT_BINARY_DIR}/config.h)

181
core/roslib/msg_gen/cpp/include/roslib/Clock.h Normal file
View File

@ -0,0 +1,181 @@
/* Auto-generated by genmsg_cpp for file /Users/kwc/ros/core/roslib/msg/Clock.msg */
#ifndef ROSLIB_MESSAGE_CLOCK_H
#define ROSLIB_MESSAGE_CLOCK_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"
namespace roslib
{
template <class ContainerAllocator>
struct Clock_ : public ros::Message
{
typedef Clock_<ContainerAllocator> Type;
Clock_()
: clock()
{
}
Clock_(const ContainerAllocator& _alloc)
: clock()
{
}
typedef ros::Time _clock_type;
ros::Time clock;
private:
static const char* __s_getDataType_() { return "roslib/Clock"; }
public:
ROSCPP_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
ROSCPP_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
private:
static const char* __s_getMD5Sum_() { return "a9c97c1d230cfc112e270351a944ee47"; }
public:
ROSCPP_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
ROSCPP_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
private:
static const char* __s_getMessageDefinition_() { return "# roslib/Clock is used for publishing simulated time in ROS. \n\
# This message simply communicates the current time.\n\
# For more information, see http://www.ros.org/wiki/Clock\n\
time clock\n\
\n\
"; }
public:
ROSCPP_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
ROSCPP_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
ROSCPP_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
{
ros::serialization::OStream stream(write_ptr, 1000000000);
ros::serialization::serialize(stream, clock);
return stream.getData();
}
ROSCPP_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
{
ros::serialization::IStream stream(read_ptr, 1000000000);
ros::serialization::deserialize(stream, clock);
return stream.getData();
}
ROSCPP_DEPRECATED virtual uint32_t serializationLength() const
{
uint32_t size = 0;
size += ros::serialization::serializationLength(clock);
return size;
}
typedef boost::shared_ptr< ::roslib::Clock_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::roslib::Clock_<ContainerAllocator> const> ConstPtr;
}; // struct Clock
typedef ::roslib::Clock_<std::allocator<void> > Clock;
typedef boost::shared_ptr< ::roslib::Clock> ClockPtr;
typedef boost::shared_ptr< ::roslib::Clock const> ClockConstPtr;
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::roslib::Clock_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::roslib::Clock_<ContainerAllocator> >::stream(s, "", v);
return s;}
} // namespace roslib
namespace ros
{
namespace message_traits
{
template<class ContainerAllocator>
struct MD5Sum< ::roslib::Clock_<ContainerAllocator> > {
static const char* value()
{
return "a9c97c1d230cfc112e270351a944ee47";
}
static const char* value(const ::roslib::Clock_<ContainerAllocator> &) { return value(); }
static const uint64_t static_value1 = 0xa9c97c1d230cfc11ULL;
static const uint64_t static_value2 = 0x2e270351a944ee47ULL;
};
template<class ContainerAllocator>
struct DataType< ::roslib::Clock_<ContainerAllocator> > {
static const char* value()
{
return "roslib/Clock";
}
static const char* value(const ::roslib::Clock_<ContainerAllocator> &) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::roslib::Clock_<ContainerAllocator> > {
static const char* value()
{
return "# roslib/Clock is used for publishing simulated time in ROS. \n\
# This message simply communicates the current time.\n\
# For more information, see http://www.ros.org/wiki/Clock\n\
time clock\n\
\n\
";
}
static const char* value(const ::roslib::Clock_<ContainerAllocator> &) { return value(); }
};
template<class ContainerAllocator> struct IsFixedSize< ::roslib::Clock_<ContainerAllocator> > : public TrueType {};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::roslib::Clock_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.clock);
}
ROS_DECLARE_ALLINONE_SERIALIZER;
}; // struct Clock_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::roslib::Clock_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::roslib::Clock_<ContainerAllocator> & v)
{
s << indent << "clock: ";
Printer<ros::Time>::stream(s, indent + " ", v.clock);
}
};
} // namespace message_operations
} // namespace ros
#endif // ROSLIB_MESSAGE_CLOCK_H

224
core/roslib/msg_gen/cpp/include/roslib/Header.h Normal file
View File

@ -0,0 +1,224 @@
/* Auto-generated by genmsg_cpp for file /Users/kwc/ros/core/roslib/msg/Header.msg */
#ifndef ROSLIB_MESSAGE_HEADER_H
#define ROSLIB_MESSAGE_HEADER_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"
namespace roslib
{
template <class ContainerAllocator>
struct Header_ : public ros::Message
{
typedef Header_<ContainerAllocator> Type;
Header_()
: seq(0)
, stamp()
, frame_id()
{
}
Header_(const ContainerAllocator& _alloc)
: seq(0)
, stamp()
, frame_id(_alloc)
{
}
typedef uint32_t _seq_type;
uint32_t seq;
typedef ros::Time _stamp_type;
ros::Time stamp;
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _frame_id_type;
std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > frame_id;
private:
static const char* __s_getDataType_() { return "roslib/Header"; }
public:
ROSCPP_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
ROSCPP_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
private:
static const char* __s_getMD5Sum_() { return "2176decaecbce78abc3b96ef049fabed"; }
public:
ROSCPP_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
ROSCPP_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
private:
static const char* __s_getMessageDefinition_() { return "# 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:
ROSCPP_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
ROSCPP_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
ROSCPP_DEPRECATED virtual uint8_t *serialize(uint8_t *write_ptr, uint32_t seq) const
{
ros::serialization::OStream stream(write_ptr, 1000000000);
ros::serialization::serialize(stream, seq);
ros::serialization::serialize(stream, stamp);
ros::serialization::serialize(stream, frame_id);
return stream.getData();
}
ROSCPP_DEPRECATED virtual uint8_t *deserialize(uint8_t *read_ptr)
{
ros::serialization::IStream stream(read_ptr, 1000000000);
ros::serialization::deserialize(stream, seq);
ros::serialization::deserialize(stream, stamp);
ros::serialization::deserialize(stream, frame_id);
return stream.getData();
}
ROSCPP_DEPRECATED virtual uint32_t serializationLength() const
{
uint32_t size = 0;
size += ros::serialization::serializationLength(seq);
size += ros::serialization::serializationLength(stamp);
size += ros::serialization::serializationLength(frame_id);
return size;
}
typedef boost::shared_ptr< ::roslib::Header_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::roslib::Header_<ContainerAllocator> const> ConstPtr;
}; // struct Header
typedef ::roslib::Header_<std::allocator<void> > Header;
typedef boost::shared_ptr< ::roslib::Header> HeaderPtr;
typedef boost::shared_ptr< ::roslib::Header const> HeaderConstPtr;
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::roslib::Header_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::roslib::Header_<ContainerAllocator> >::stream(s, "", v);
return s;}
} // namespace roslib
namespace ros
{
namespace message_traits
{
template<class ContainerAllocator>
struct MD5Sum< ::roslib::Header_<ContainerAllocator> > {
static const char* value()
{
return "2176decaecbce78abc3b96ef049fabed";
}
static const char* value(const ::roslib::Header_<ContainerAllocator> &) { return value(); }
static const uint64_t static_value1 = 0x2176decaecbce78aULL;
static const uint64_t static_value2 = 0xbc3b96ef049fabedULL;
};
template<class ContainerAllocator>
struct DataType< ::roslib::Header_<ContainerAllocator> > {
static const char* value()
{
return "roslib/Header";
}
static const char* value(const ::roslib::Header_<ContainerAllocator> &) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::roslib::Header_<ContainerAllocator> > {
static const char* value()
{
return "# 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 ::roslib::Header_<ContainerAllocator> &) { return value(); }
};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::roslib::Header_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.seq);
stream.next(m.stamp);
stream.next(m.frame_id);
}
ROS_DECLARE_ALLINONE_SERIALIZER;
}; // struct Header_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::roslib::Header_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::roslib::Header_<ContainerAllocator> & v)
{
s << indent << "seq: ";
Printer<uint32_t>::stream(s, indent + " ", v.seq);
s << indent << "stamp: ";
Printer<ros::Time>::stream(s, indent + " ", v.stamp);
s << indent << "frame_id: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.frame_id);
}
};
} // namespace message_operations
} // namespace ros
#endif // ROSLIB_MESSAGE_HEADER_H

339
core/roslib/msg_gen/cpp/include/roslib/Log.h Normal file
View File

@ -0,0 +1,339 @@
/* Auto-generated by genmsg_cpp for file /Users/kwc/ros/core/roslib/msg/Log.msg */
#ifndef ROSLIB_MESSAGE_LOG_H
#define ROSLIB_MESSAGE_LOG_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 "roslib/Header.h"
namespace roslib
{
template <class ContainerAllocator>
struct Log_ : public ros::Message
{
typedef Log_<ContainerAllocator> Type;
Log_()
: header()
, level(0)
, name()
, msg()
, file()
, function()
, line(0)
, topics()
{
}
Log_(const ContainerAllocator& _alloc)
: header(_alloc)
, level(0)
, name(_alloc)
, msg(_alloc)
, file(_alloc)
, function(_alloc)
, line(0)
, topics(_alloc)
{
}
typedef ::roslib::Header_<ContainerAllocator> _header_type;
::roslib::Header_<ContainerAllocator> header;
typedef int8_t _level_type;
int8_t level;
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _name_type;
std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > name;
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _msg_type;
std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > msg;
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _file_type;
std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > file;
typedef std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > _function_type;
std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > function;
typedef uint32_t _line_type;
uint32_t line;
typedef std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > _topics_type;
std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > topics;
enum { DEBUG = 1 };
enum { INFO = 2 };
enum { WARN = 4 };
enum { ERROR = 8 };
enum { FATAL = 16 };
ROSCPP_DEPRECATED uint32_t get_topics_size() const { return (uint32_t)topics.size(); }
ROSCPP_DEPRECATED void set_topics_size(uint32_t size) { topics.resize((size_t)size); }
ROSCPP_DEPRECATED void get_topics_vec(std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > & vec) const { vec = this->topics; }
ROSCPP_DEPRECATED void set_topics_vec(const std::vector<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > , typename ContainerAllocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > & vec) { this->topics = vec; }
private:
static const char* __s_getDataType_() { return "roslib/Log"; }
public:
ROSCPP_DEPRECATED static const std::string __s_getDataType() { return __s_getDataType_(); }
ROSCPP_DEPRECATED const std::string __getDataType() const { return __s_getDataType_(); }
private:
static const char* __s_getMD5Sum_() { return "acffd30cd6b6de30f120938c17c593fb"; }
public:
ROSCPP_DEPRECATED static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }
ROSCPP_DEPRECATED const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }
private:
static const char* __s_getMessageDefinition_() { return "##\n\
## Severity level constants\n\
##\n\
byte DEBUG=1 #debug level\n\
byte INFO=2 #general level\n\
byte WARN=4 #warning level\n\
byte ERROR=8 #error level\n\
byte FATAL=16 #fatal/critical level\n\
##\n\
## Fields\n\
##\n\
Header header\n\
byte level\n\
string name # name of the node\n\
string msg # message \n\
string file # file the message came from\n\
string function # function the message came from\n\
uint32 line # line the message came from\n\
string[] topics # topic names that the node publishes\n\
\n\
================================================================================\n\
MSG: roslib/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:
ROSCPP_DEPRECATED static const std::string __s_getMessageDefinition() { return __s_getMessageDefinition_(); }
ROSCPP_DEPRECATED const std::string __getMessageDefinition() const { return __s_getMessageDefinition_(); }
ROSCPP_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, level);
ros::serialization::serialize(stream, name);
ros::serialization::serialize(stream, msg);
ros::serialization::serialize(stream, file);
ros::serialization::serialize(stream, function);
ros::serialization::serialize(stream, line);
ros::serialization::serialize(stream, topics);
return stream.getData();
}
ROSCPP_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, level);
ros::serialization::deserialize(stream, name);
ros::serialization::deserialize(stream, msg);
ros::serialization::deserialize(stream, file);
ros::serialization::deserialize(stream, function);
ros::serialization::deserialize(stream, line);
ros::serialization::deserialize(stream, topics);
return stream.getData();
}
ROSCPP_DEPRECATED virtual uint32_t serializationLength() const
{
uint32_t size = 0;
size += ros::serialization::serializationLength(header);
size += ros::serialization::serializationLength(level);
size += ros::serialization::serializationLength(name);
size += ros::serialization::serializationLength(msg);
size += ros::serialization::serializationLength(file);
size += ros::serialization::serializationLength(function);
size += ros::serialization::serializationLength(line);
size += ros::serialization::serializationLength(topics);
return size;
}
typedef boost::shared_ptr< ::roslib::Log_<ContainerAllocator> > Ptr;
typedef boost::shared_ptr< ::roslib::Log_<ContainerAllocator> const> ConstPtr;
}; // struct Log
typedef ::roslib::Log_<std::allocator<void> > Log;
typedef boost::shared_ptr< ::roslib::Log> LogPtr;
typedef boost::shared_ptr< ::roslib::Log const> LogConstPtr;
template<typename ContainerAllocator>
std::ostream& operator<<(std::ostream& s, const ::roslib::Log_<ContainerAllocator> & v)
{
ros::message_operations::Printer< ::roslib::Log_<ContainerAllocator> >::stream(s, "", v);
return s;}
} // namespace roslib
namespace ros
{
namespace message_traits
{
template<class ContainerAllocator>
struct MD5Sum< ::roslib::Log_<ContainerAllocator> > {
static const char* value()
{
return "acffd30cd6b6de30f120938c17c593fb";
}
static const char* value(const ::roslib::Log_<ContainerAllocator> &) { return value(); }
static const uint64_t static_value1 = 0xacffd30cd6b6de30ULL;
static const uint64_t static_value2 = 0xf120938c17c593fbULL;
};
template<class ContainerAllocator>
struct DataType< ::roslib::Log_<ContainerAllocator> > {
static const char* value()
{
return "roslib/Log";
}
static const char* value(const ::roslib::Log_<ContainerAllocator> &) { return value(); }
};
template<class ContainerAllocator>
struct Definition< ::roslib::Log_<ContainerAllocator> > {
static const char* value()
{
return "##\n\
## Severity level constants\n\
##\n\
byte DEBUG=1 #debug level\n\
byte INFO=2 #general level\n\
byte WARN=4 #warning level\n\
byte ERROR=8 #error level\n\
byte FATAL=16 #fatal/critical level\n\
##\n\
## Fields\n\
##\n\
Header header\n\
byte level\n\
string name # name of the node\n\
string msg # message \n\
string file # file the message came from\n\
string function # function the message came from\n\
uint32 line # line the message came from\n\
string[] topics # topic names that the node publishes\n\
\n\
================================================================================\n\
MSG: roslib/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 ::roslib::Log_<ContainerAllocator> &) { return value(); }
};
template<class ContainerAllocator> struct HasHeader< ::roslib::Log_<ContainerAllocator> > : public TrueType {};
} // namespace message_traits
} // namespace ros
namespace ros
{
namespace serialization
{
template<class ContainerAllocator> struct Serializer< ::roslib::Log_<ContainerAllocator> >
{
template<typename Stream, typename T> inline static void allInOne(Stream& stream, T m)
{
stream.next(m.header);
stream.next(m.level);
stream.next(m.name);
stream.next(m.msg);
stream.next(m.file);
stream.next(m.function);
stream.next(m.line);
stream.next(m.topics);
}
ROS_DECLARE_ALLINONE_SERIALIZER;
}; // struct Log_
} // namespace serialization
} // namespace ros
namespace ros
{
namespace message_operations
{
template<class ContainerAllocator>
struct Printer< ::roslib::Log_<ContainerAllocator> >
{
template<typename Stream> static void stream(Stream& s, const std::string& indent, const ::roslib::Log_<ContainerAllocator> & v)
{
s << indent << "header: ";
s << std::endl;
Printer< ::roslib::Header_<ContainerAllocator> >::stream(s, indent + " ", v.header);
s << indent << "level: ";
Printer<int8_t>::stream(s, indent + " ", v.level);
s << indent << "name: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.name);
s << indent << "msg: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.msg);
s << indent << "file: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.file);
s << indent << "function: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.function);
s << indent << "line: ";
Printer<uint32_t>::stream(s, indent + " ", v.line);
s << indent << "topics[]" << std::endl;
for (size_t i = 0; i < v.topics.size(); ++i)
{
s << indent << " topics[" << i << "]: ";
Printer<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.topics[i]);
}
}
};
} // namespace message_operations
} // namespace ros
#endif // ROSLIB_MESSAGE_LOG_H

116
core/roslib/src/roslib/msg/_Clock.py Normal file
View File

@ -0,0 +1,116 @@
"""autogenerated by genmsg_py from Clock.msg. Do not edit."""
import roslib.message
import struct
import roslib.rostime
class Clock(roslib.message.Message):
_md5sum = "a9c97c1d230cfc112e270351a944ee47"
_type = "roslib/Clock"
_has_header = False #flag to mark the presence of a Header object
_full_text = """# roslib/Clock is used for publishing simulated time in ROS.
# This message simply communicates the current time.
# For more information, see http://www.ros.org/wiki/Clock
time clock
"""
__slots__ = ['clock']
_slot_types = ['time']
def __init__(self, *args, **kwds):
"""
Constructor. Any message fields that are implicitly/explicitly
set to None will be assigned a default value. The recommend
use is keyword arguments as this is more robust to future message
changes. You cannot mix in-order arguments and keyword arguments.
The available fields are:
clock
@param args: complete set of field values, in .msg order
@param kwds: use keyword arguments corresponding to message field names
to set specific fields.
"""
if args or kwds:
super(Clock, self).__init__(*args, **kwds)
#message fields cannot be None, assign default values for those that are
if self.clock is None:
self.clock = roslib.rostime.Time()
else:
self.clock = roslib.rostime.Time()
def _get_types(self):
"""
internal API method
"""
return self._slot_types
def serialize(self, buff):
"""
serialize message into buffer
@param buff: buffer
@type buff: StringIO
"""
try:
_x = self
buff.write(_struct_2I.pack(_x.clock.secs, _x.clock.nsecs))
except struct.error, se: self._check_types(se)
except TypeError, te: self._check_types(te)
def deserialize(self, str):
"""
unpack serialized message in str into this message instance
@param str: byte array of serialized message
@type str: str
"""
try:
if self.clock is None:
self.clock = roslib.rostime.Time()
end = 0
_x = self
start = end
end += 8
(_x.clock.secs, _x.clock.nsecs,) = _struct_2I.unpack(str[start:end])
self.clock.canon()
return self
except struct.error, e:
raise roslib.message.DeserializationError(e) #most likely buffer underfill
def serialize_numpy(self, buff, numpy):
"""
serialize message with numpy array types into buffer
@param buff: buffer
@type buff: StringIO
@param numpy: numpy python module
@type numpy module
"""
try:
_x = self
buff.write(_struct_2I.pack(_x.clock.secs, _x.clock.nsecs))
except struct.error, se: self._check_types(se)
except TypeError, te: self._check_types(te)
def deserialize_numpy(self, str, numpy):
"""
unpack serialized message in str into this message instance using numpy for array types
@param str: byte array of serialized message
@type str: str
@param numpy: numpy python module
@type numpy: module
"""
try:
if self.clock is None:
self.clock = roslib.rostime.Time()
end = 0
_x = self
start = end
end += 8
(_x.clock.secs, _x.clock.nsecs,) = _struct_2I.unpack(str[start:end])
self.clock.canon()
return self
except struct.error, e:
raise roslib.message.DeserializationError(e) #most likely buffer underfill
_struct_I = roslib.message.struct_I
_struct_2I = struct.Struct("<2I")

151
core/roslib/src/roslib/msg/_Header.py Normal file
View File

@ -0,0 +1,151 @@
"""autogenerated by genmsg_py from Header.msg. Do not edit."""
import roslib.message
import struct
import roslib.rostime
class Header(roslib.message.Message):
_md5sum = "2176decaecbce78abc3b96ef049fabed"
_type = "roslib/Header"
_has_header = False #flag to mark the presence of a Header object
_full_text = """# Standard metadata for higher-level stamped data types.
# This is generally used to communicate timestamped data
# in a particular coordinate frame.
#
# sequence ID: consecutively increasing ID
uint32 seq
#Two-integer timestamp that is expressed as:
# * stamp.secs: seconds (stamp_secs) since epoch
# * stamp.nsecs: nanoseconds since stamp_secs
# time-handling sugar is provided by the client library
time stamp
#Frame this data is associated with
# 0: no frame
# 1: global frame
string frame_id
"""
__slots__ = ['seq','stamp','frame_id']
_slot_types = ['uint32','time','string']
def __init__(self, *args, **kwds):
"""
Constructor. Any message fields that are implicitly/explicitly
set to None will be assigned a default value. The recommend
use is keyword arguments as this is more robust to future message
changes. You cannot mix in-order arguments and keyword arguments.
The available fields are:
seq,stamp,frame_id
@param args: complete set of field values, in .msg order
@param kwds: use keyword arguments corresponding to message field names
to set specific fields.
"""
if args or kwds:
super(Header, self).__init__(*args, **kwds)
#message fields cannot be None, assign default values for those that are
if self.seq is None:
self.seq = 0
if self.stamp is None:
self.stamp = roslib.rostime.Time()
if self.frame_id is None:
self.frame_id = ''
else:
self.seq = 0
self.stamp = roslib.rostime.Time()
self.frame_id = ''
def _get_types(self):
"""
internal API method
"""
return self._slot_types
def serialize(self, buff):
"""
serialize message into buffer
@param buff: buffer
@type buff: StringIO
"""
try:
_x = self
buff.write(_struct_3I.pack(_x.seq, _x.stamp.secs, _x.stamp.nsecs))
_x = self.frame_id
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
except struct.error, se: self._check_types(se)
except TypeError, te: self._check_types(te)
def deserialize(self, str):
"""
unpack serialized message in str into this message instance
@param str: byte array of serialized message
@type str: str
"""
try:
if self.stamp is None:
self.stamp = roslib.rostime.Time()
end = 0
_x = self
start = end
end += 12
(_x.seq, _x.stamp.secs, _x.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.frame_id = str[start:end]
self.stamp.canon()
return self
except struct.error, e:
raise roslib.message.DeserializationError(e) #most likely buffer underfill
def serialize_numpy(self, buff, numpy):
"""
serialize message with numpy array types into buffer
@param buff: buffer
@type buff: StringIO
@param numpy: numpy python module
@type numpy module
"""
try:
_x = self
buff.write(_struct_3I.pack(_x.seq, _x.stamp.secs, _x.stamp.nsecs))
_x = self.frame_id
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
except struct.error, se: self._check_types(se)
except TypeError, te: self._check_types(te)
def deserialize_numpy(self, str, numpy):
"""
unpack serialized message in str into this message instance using numpy for array types
@param str: byte array of serialized message
@type str: str
@param numpy: numpy python module
@type numpy: module
"""
try:
if self.stamp is None:
self.stamp = roslib.rostime.Time()
end = 0
_x = self
start = end
end += 12
(_x.seq, _x.stamp.secs, _x.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.frame_id = str[start:end]
self.stamp.canon()
return self
except struct.error, e:
raise roslib.message.DeserializationError(e) #most likely buffer underfill
_struct_I = roslib.message.struct_I
_struct_3I = struct.Struct("<3I")

316
core/roslib/src/roslib/msg/_Log.py Normal file
View File

@ -0,0 +1,316 @@
"""autogenerated by genmsg_py from Log.msg. Do not edit."""
import roslib.message
import struct
import roslib.msg
class Log(roslib.message.Message):
_md5sum = "acffd30cd6b6de30f120938c17c593fb"
_type = "roslib/Log"
_has_header = True #flag to mark the presence of a Header object
_full_text = """##
## Severity level constants
##
byte DEBUG=1 #debug level
byte INFO=2 #general level
byte WARN=4 #warning level
byte ERROR=8 #error level
byte FATAL=16 #fatal/critical level
##
## Fields
##
Header header
byte level
string name # name of the node
string msg # message
string file # file the message came from
string function # function the message came from
uint32 line # line the message came from
string[] topics # topic names that the node publishes
================================================================================
MSG: roslib/Header
# Standard metadata for higher-level stamped data types.
# This is generally used to communicate timestamped data
# in a particular coordinate frame.
#
# sequence ID: consecutively increasing ID
uint32 seq
#Two-integer timestamp that is expressed as:
# * stamp.secs: seconds (stamp_secs) since epoch
# * stamp.nsecs: nanoseconds since stamp_secs
# time-handling sugar is provided by the client library
time stamp
#Frame this data is associated with
# 0: no frame
# 1: global frame
string frame_id
"""
# Pseudo-constants
DEBUG = 1
INFO = 2
WARN = 4
ERROR = 8
FATAL = 16
__slots__ = ['header','level','name','msg','file','function','line','topics']
_slot_types = ['Header','byte','string','string','string','string','uint32','string[]']
def __init__(self, *args, **kwds):
"""
Constructor. Any message fields that are implicitly/explicitly
set to None will be assigned a default value. The recommend
use is keyword arguments as this is more robust to future message
changes. You cannot mix in-order arguments and keyword arguments.
The available fields are:
header,level,name,msg,file,function,line,topics
@param args: complete set of field values, in .msg order
@param kwds: use keyword arguments corresponding to message field names
to set specific fields.
"""
if args or kwds:
super(Log, self).__init__(*args, **kwds)
#message fields cannot be None, assign default values for those that are
if self.header is None:
self.header = roslib.msg._Header.Header()
if self.level is None:
self.level = 0
if self.name is None:
self.name = ''
if self.msg is None:
self.msg = ''
if self.file is None:
self.file = ''
if self.function is None:
self.function = ''
if self.line is None:
self.line = 0
if self.topics is None:
self.topics = []
else:
self.header = roslib.msg._Header.Header()
self.level = 0
self.name = ''
self.msg = ''
self.file = ''
self.function = ''
self.line = 0
self.topics = []
def _get_types(self):
"""
internal API method
"""
return self._slot_types
def serialize(self, buff):
"""
serialize message into buffer
@param buff: buffer
@type buff: StringIO
"""
try:
_x = self
buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
_x = self.header.frame_id
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
buff.write(_struct_b.pack(self.level))
_x = self.name
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
_x = self.msg
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
_x = self.file
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
_x = self.function
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
buff.write(_struct_I.pack(self.line))
length = len(self.topics)
buff.write(_struct_I.pack(length))
for val1 in self.topics:
length = len(val1)
buff.write(struct.pack('<I%ss'%length, length, val1))
except struct.error, se: self._check_types(se)
except TypeError, te: self._check_types(te)
def deserialize(self, str):
"""
unpack serialized message in str into this message instance
@param str: byte array of serialized message
@type str: str
"""
try:
if self.header is None:
self.header = roslib.msg._Header.Header()
end = 0
_x = self
start = end
end += 12
(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.header.frame_id = str[start:end]
start = end
end += 1
(self.level,) = _struct_b.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.name = str[start:end]
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.msg = str[start:end]
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.file = str[start:end]
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.function = str[start:end]
start = end
end += 4
(self.line,) = _struct_I.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
self.topics = []
for i in xrange(0, length):
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
val1 = str[start:end]
self.topics.append(val1)
return self
except struct.error, e:
raise roslib.message.DeserializationError(e) #most likely buffer underfill
def serialize_numpy(self, buff, numpy):
"""
serialize message with numpy array types into buffer
@param buff: buffer
@type buff: StringIO
@param numpy: numpy python module
@type numpy module
"""
try:
_x = self
buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
_x = self.header.frame_id
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
buff.write(_struct_b.pack(self.level))
_x = self.name
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
_x = self.msg
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
_x = self.file
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
_x = self.function
length = len(_x)
buff.write(struct.pack('<I%ss'%length, length, _x))
buff.write(_struct_I.pack(self.line))
length = len(self.topics)
buff.write(_struct_I.pack(length))
for val1 in self.topics:
length = len(val1)
buff.write(struct.pack('<I%ss'%length, length, val1))
except struct.error, se: self._check_types(se)
except TypeError, te: self._check_types(te)
def deserialize_numpy(self, str, numpy):
"""
unpack serialized message in str into this message instance using numpy for array types
@param str: byte array of serialized message
@type str: str
@param numpy: numpy python module
@type numpy: module
"""
try:
if self.header is None:
self.header = roslib.msg._Header.Header()
end = 0
_x = self
start = end
end += 12
(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs,) = _struct_3I.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.header.frame_id = str[start:end]
start = end
end += 1
(self.level,) = _struct_b.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.name = str[start:end]
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.msg = str[start:end]
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.file = str[start:end]
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
self.function = str[start:end]
start = end
end += 4
(self.line,) = _struct_I.unpack(str[start:end])
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
self.topics = []
for i in xrange(0, length):
start = end
end += 4
(length,) = _struct_I.unpack(str[start:end])
start = end
end += length
val1 = str[start:end]
self.topics.append(val1)
return self
except struct.error, e:
raise roslib.message.DeserializationError(e) #most likely buffer underfill
_struct_I = roslib.message.struct_I
_struct_3I = struct.Struct("<3I")
_struct_b = struct.Struct("<b")

3
core/roslib/src/roslib/msg/__init__.py Normal file
View File

@ -0,0 +1,3 @@
from _Header import *
from _Log import *
from _Clock import *