ros: headers diff between 2.0-cturtle and 3.0-diamondback versions

	Clock.h	Clock.h

	/* Auto-generated by genmsg_cpp for file /home/andrey/install/ros-2.0-cturt	#warning("This header has been deprecated in favor of rosgraph_msgs/Clock.h
	le/ros/core/roslib/msg/Clock.msg */	")

		/* Auto-generated by genmsg_cpp for file /Users/kwc/ros/core/roslib/msg/Clo
		ck.msg */
	#ifndef ROSLIB_MESSAGE_CLOCK_H	#ifndef ROSLIB_MESSAGE_CLOCK_H
	#define ROSLIB_MESSAGE_CLOCK_H	#define ROSLIB_MESSAGE_CLOCK_H
	#include <string>	#include <string>
	#include <vector>	#include <vector>
	#include <ostream>	#include <ostream>
	#include "ros/serialization.h"	#include "ros/serialization.h"
	#include "ros/builtin_message_traits.h"	#include "ros/builtin_message_traits.h"
	#include "ros/message_operations.h"	#include "ros/message_operations.h"
	#include "ros/message.h"	#include "ros/message.h"
	#include "ros/time.h"	#include "ros/time.h"

	skipping to change at line 36	skipping to change at line 38
	: clock()	: clock()
	{	{
	}	}

	typedef ros::Time _clock_type;	typedef ros::Time _clock_type;
	ros::Time clock;	ros::Time clock;

	private:	private:
	static const char* __s_getDataType_() { return "roslib/Clock"; }	static const char* __s_getDataType_() { return "roslib/Clock"; }
	public:	public:

	ROSCPP_DEPRECATED static const std::string __s_getDataType() { return __s _getDataType_(); }	static const std::string __s_getDataType() { return __s_getDataType_(); }


	ROSCPP_DEPRECATED const std::string __getDataType() const { return __s_ge tDataType_(); }	const std::string __getDataType() const { return __s_getDataType_(); }

	private:	private:
	static const char* __s_getMD5Sum_() { return "a9c97c1d230cfc112e270351a94 4ee47"; }	static const char* __s_getMD5Sum_() { return "a9c97c1d230cfc112e270351a94 4ee47"; }
	public:	public:

	ROSCPP_DEPRECATED static const std::string __s_getMD5Sum() { return __s_g etMD5Sum_(); }	static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }


	ROSCPP_DEPRECATED const std::string __getMD5Sum() const { return __s_getM D5Sum_(); }	const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }

	private:	private:
	static const char* __s_getMessageDefinition_() { return "# roslib/Clock i s used for publishing simulated time in ROS. \n\	static const char* __s_getMessageDefinition_() { return "# roslib/Clock i s used for publishing simulated time in ROS. \n\
	# This message simply communicates the current time.\n\	# This message simply communicates the current time.\n\
	# For more information, see http://www.ros.org/wiki/Clock\n\	# For more information, see http://www.ros.org/wiki/Clock\n\
	time clock\n\	time clock\n\
	\n\	\n\
	"; }	"; }
	public:	public:

	ROSCPP_DEPRECATED static const std::string __s_getMessageDefinition() { r eturn __s_getMessageDefinition_(); }	static const std::string __s_getMessageDefinition() { return __s_getMess ageDefinition_(); }


	ROSCPP_DEPRECATED const std::string __getMessageDefinition() const { retu rn __s_getMessageDefinition_(); }	const std::string __getMessageDefinition() const { return __s_getMessage Definition_(); }


	ROSCPP_DEPRECATED virtual uint8_t serialize(uint8_t write_ptr, uint32_t seq) const	virtual uint8_t serialize(uint8_t write_ptr, uint32_t seq) const
	{	{
	ros::serialization::OStream stream(write_ptr, 1000000000);	ros::serialization::OStream stream(write_ptr, 1000000000);
	ros::serialization::serialize(stream, clock);	ros::serialization::serialize(stream, clock);
	return stream.getData();	return stream.getData();
	}	}


	ROSCPP_DEPRECATED virtual uint8_t deserialize(uint8_t read_ptr)	virtual uint8_t deserialize(uint8_t read_ptr)
	{	{
	ros::serialization::IStream stream(read_ptr, 1000000000);	ros::serialization::IStream stream(read_ptr, 1000000000);
	ros::serialization::deserialize(stream, clock);	ros::serialization::deserialize(stream, clock);
	return stream.getData();	return stream.getData();
	}	}


	ROSCPP_DEPRECATED virtual uint32_t serializationLength() const	virtual uint32_t serializationLength() const
	{	{
	uint32_t size = 0;	uint32_t size = 0;
	size += ros::serialization::serializationLength(clock);	size += ros::serialization::serializationLength(clock);
	return size;	return size;
	}	}

	typedef boost::shared_ptr< ::roslib::Clock_<ContainerAllocator> > Ptr;	typedef boost::shared_ptr< ::roslib::Clock_<ContainerAllocator> > Ptr;
	typedef boost::shared_ptr< ::roslib::Clock_<ContainerAllocator> const> C onstPtr;	typedef boost::shared_ptr< ::roslib::Clock_<ContainerAllocator> const> C onstPtr;
	}; // struct Clock	}; // struct Clock
	typedef ::roslib::Clock_<std::allocator<void> > Clock;	typedef ::roslib::Clock_<std::allocator<void> > Clock;

End of changes. 10 change blocks.
	11 lines changed or deleted	14 lines changed or added

	Header.h	Header.h

	/* Auto-generated by genmsg_cpp for file /home/andrey/install/ros-2.0-cturt	#warning("This header has been deprecated in favor of std_msgs/Header.h")
	le/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 Containe
	rAllocator::template rebind<char>::other > _frame_id_type;
	std::basic_string<char, std::char_traits<char>, typename ContainerAllocat
	or::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_ge
	tDataType_(); }

	private:
	static const char* __s_getMD5Sum_() { return "2176decaecbce78abc3b96ef049
	fabed"; }
	public:
	ROSCPP_DEPRECATED static const std::string __s_getMD5Sum() { return __s_g
	etMD5Sum_(); }

	ROSCPP_DEPRECATED const std::string __getMD5Sum() const { return __s_getM
	D5Sum_(); }

	private:
	static const char* __s_getMessageDefinition_() { return "# Standard metad
	ata 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() { r
	eturn __s_getMessageDefinition_(); }

	ROSCPP_DEPRECATED const std::string __getMessageDefinition() const { retu
	rn __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_<Containe
	rAllocator> & 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_<Con
	tainerAllocator> >
	{
	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 Contai
	nerAllocator::template rebind<char>::other > >::stream(s, indent + " ", v.
	frame_id);
	}
	};

	} // namespace message_operations
	} // namespace ros


	#endif // ROSLIB_MESSAGE_HEADER_H	#include <std_msgs/Header.h>

End of changes. 2 change blocks.
	240 lines changed or deleted	1 lines changed or added

	Log.h	Log.h

	/* Auto-generated by genmsg_cpp for file /home/andrey/install/ros-2.0-cturt	#warning("This header has been deprecated in favor of rosgraph_msgs/Log.h")
	le/ros/core/roslib/msg/Log.msg */
		/* Auto-generated by genmsg_cpp for file /Users/kwc/ros/core/roslib/msg/Log
		.msg */
	#ifndef ROSLIB_MESSAGE_LOG_H	#ifndef ROSLIB_MESSAGE_LOG_H
	#define ROSLIB_MESSAGE_LOG_H	#define ROSLIB_MESSAGE_LOG_H
	#include <string>	#include <string>
	#include <vector>	#include <vector>
	#include <ostream>	#include <ostream>
	#include "ros/serialization.h"	#include "ros/serialization.h"
	#include "ros/builtin_message_traits.h"	#include "ros/builtin_message_traits.h"
	#include "ros/message_operations.h"	#include "ros/message_operations.h"
	#include "ros/message.h"	#include "ros/message.h"
	#include "ros/time.h"	#include "ros/time.h"

	skipping to change at line 76	skipping to change at line 78

	typedef std::vector<std::basic_string<char, std::char_traits<char>, typen ame ContainerAllocator::template rebind<char>::other > , typename Container Allocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > _to pics_type;	typedef std::vector<std::basic_string<char, std::char_traits<char>, typen ame ContainerAllocator::template rebind<char>::other > , typename Container Allocator::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > _to pics_type;
	std::vector<std::basic_string<char, std::char_traits<char>, typename Cont ainerAllocator::template rebind<char>::other > , typename ContainerAllocato r::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > topics;	std::vector<std::basic_string<char, std::char_traits<char>, typename Cont ainerAllocator::template rebind<char>::other > , typename ContainerAllocato r::template rebind<std::basic_string<char, std::char_traits<char>, typename ContainerAllocator::template rebind<char>::other > >::other > topics;

	enum { DEBUG = 1 };	enum { DEBUG = 1 };
	enum { INFO = 2 };	enum { INFO = 2 };
	enum { WARN = 4 };	enum { WARN = 4 };
	enum { ERROR = 8 };	enum { ERROR = 8 };
	enum { FATAL = 16 };	enum { FATAL = 16 };


	ROSCPP_DEPRECATED uint32_t get_topics_size() const { return (uint32_t)top	uint32_t get_topics_size() const { return (uint32_t)topics.size(); }
	ics.size(); }	void set_topics_size(uint32_t size) { topics.resize((size_t)size); }
	ROSCPP_DEPRECATED void set_topics_size(uint32_t size) { topics.resize((si	void get_topics_vec(std::vector<std::basic_string<char, std::char_traits
	ze_t)size); }	<char>, typename ContainerAllocator::template rebind<char>::other > , typen
	ROSCPP_DEPRECATED void get_topics_vec(std::vector<std::basic_string<char,	ame ContainerAllocator::template rebind<std::basic_string<char, std::char_t
	std::char_traits<char>, typename ContainerAllocator::template rebind<char>	raits<char>, typename ContainerAllocator::template rebind<char>::other > >:
	::other > , typename ContainerAllocator::template rebind<std::basic_string<	:other > & vec) const { vec = this->topics; }
	char, std::char_traits<char>, typename ContainerAllocator::template rebind<	void set_topics_vec(const std::vector<std::basic_string<char, std::char_
	char>::other > >::other > & vec) const { vec = this->topics; }	traits<char>, typename ContainerAllocator::template rebind<char>::other > ,
	ROSCPP_DEPRECATED void set_topics_vec(const std::vector<std::basic_string	typename ContainerAllocator::template rebind<std::basic_string<char, std::
	<char, std::char_traits<char>, typename ContainerAllocator::template rebind	char_traits<char>, typename ContainerAllocator::template rebind<char>::othe
	<char>::other > , typename ContainerAllocator::template rebind<std::basic_s	r > >::other > & vec) { this->topics = vec; }
	tring<char, std::char_traits<char>, typename ContainerAllocator::template r
	ebind<char>::other > >::other > & vec) { this->topics = vec; }
	private:	private:
	static const char* __s_getDataType_() { return "roslib/Log"; }	static const char* __s_getDataType_() { return "roslib/Log"; }
	public:	public:

	ROSCPP_DEPRECATED static const std::string __s_getDataType() { return __s _getDataType_(); }	static const std::string __s_getDataType() { return __s_getDataType_(); }


	ROSCPP_DEPRECATED const std::string __getDataType() const { return __s_ge tDataType_(); }	const std::string __getDataType() const { return __s_getDataType_(); }

	private:	private:
	static const char* __s_getMD5Sum_() { return "acffd30cd6b6de30f120938c17c 593fb"; }	static const char* __s_getMD5Sum_() { return "acffd30cd6b6de30f120938c17c 593fb"; }
	public:	public:

	ROSCPP_DEPRECATED static const std::string __s_getMD5Sum() { return __s_g etMD5Sum_(); }	static const std::string __s_getMD5Sum() { return __s_getMD5Sum_(); }


	ROSCPP_DEPRECATED const std::string __getMD5Sum() const { return __s_getM D5Sum_(); }	const std::string __getMD5Sum() const { return __s_getMD5Sum_(); }

	private:	private:
	static const char* __s_getMessageDefinition_() { return "##\n\	static const char* __s_getMessageDefinition_() { return "##\n\
	## Severity level constants\n\	## Severity level constants\n\
	##\n\	##\n\
	byte DEBUG=1 #debug level\n\	byte DEBUG=1 #debug level\n\
	byte INFO=2 #general level\n\	byte INFO=2 #general level\n\
	byte WARN=4 #warning level\n\	byte WARN=4 #warning level\n\
	byte ERROR=8 #error level\n\	byte ERROR=8 #error level\n\
	byte FATAL=16 #fatal/critical level\n\	byte FATAL=16 #fatal/critical level\n\

	skipping to change at line 135	skipping to change at line 137
	# * stamp.nsecs: nanoseconds since stamp_secs\n\	# * stamp.nsecs: nanoseconds since stamp_secs\n\
	# time-handling sugar is provided by the client library\n\	# time-handling sugar is provided by the client library\n\
	time stamp\n\	time stamp\n\
	#Frame this data is associated with\n\	#Frame this data is associated with\n\
	# 0: no frame\n\	# 0: no frame\n\
	# 1: global frame\n\	# 1: global frame\n\
	string frame_id\n\	string frame_id\n\
	\n\	\n\
	"; }	"; }
	public:	public:

	ROSCPP_DEPRECATED static const std::string __s_getMessageDefinition() { r eturn __s_getMessageDefinition_(); }	static const std::string __s_getMessageDefinition() { return __s_getMess ageDefinition_(); }


	ROSCPP_DEPRECATED const std::string __getMessageDefinition() const { retu rn __s_getMessageDefinition_(); }	const std::string __getMessageDefinition() const { return __s_getMessage Definition_(); }


	ROSCPP_DEPRECATED virtual uint8_t serialize(uint8_t write_ptr, uint32_t seq) const	virtual uint8_t serialize(uint8_t write_ptr, uint32_t seq) const
	{	{
	ros::serialization::OStream stream(write_ptr, 1000000000);	ros::serialization::OStream stream(write_ptr, 1000000000);
	ros::serialization::serialize(stream, header);	ros::serialization::serialize(stream, header);
	ros::serialization::serialize(stream, level);	ros::serialization::serialize(stream, level);
	ros::serialization::serialize(stream, name);	ros::serialization::serialize(stream, name);
	ros::serialization::serialize(stream, msg);	ros::serialization::serialize(stream, msg);
	ros::serialization::serialize(stream, file);	ros::serialization::serialize(stream, file);
	ros::serialization::serialize(stream, function);	ros::serialization::serialize(stream, function);
	ros::serialization::serialize(stream, line);	ros::serialization::serialize(stream, line);
	ros::serialization::serialize(stream, topics);	ros::serialization::serialize(stream, topics);
	return stream.getData();	return stream.getData();
	}	}


	ROSCPP_DEPRECATED virtual uint8_t deserialize(uint8_t read_ptr)	virtual uint8_t deserialize(uint8_t read_ptr)
	{	{
	ros::serialization::IStream stream(read_ptr, 1000000000);	ros::serialization::IStream stream(read_ptr, 1000000000);
	ros::serialization::deserialize(stream, header);	ros::serialization::deserialize(stream, header);
	ros::serialization::deserialize(stream, level);	ros::serialization::deserialize(stream, level);
	ros::serialization::deserialize(stream, name);	ros::serialization::deserialize(stream, name);
	ros::serialization::deserialize(stream, msg);	ros::serialization::deserialize(stream, msg);
	ros::serialization::deserialize(stream, file);	ros::serialization::deserialize(stream, file);
	ros::serialization::deserialize(stream, function);	ros::serialization::deserialize(stream, function);
	ros::serialization::deserialize(stream, line);	ros::serialization::deserialize(stream, line);
	ros::serialization::deserialize(stream, topics);	ros::serialization::deserialize(stream, topics);
	return stream.getData();	return stream.getData();
	}	}


	ROSCPP_DEPRECATED virtual uint32_t serializationLength() const	virtual uint32_t serializationLength() const
	{	{
	uint32_t size = 0;	uint32_t size = 0;
	size += ros::serialization::serializationLength(header);	size += ros::serialization::serializationLength(header);
	size += ros::serialization::serializationLength(level);	size += ros::serialization::serializationLength(level);
	size += ros::serialization::serializationLength(name);	size += ros::serialization::serializationLength(name);
	size += ros::serialization::serializationLength(msg);	size += ros::serialization::serializationLength(msg);
	size += ros::serialization::serializationLength(file);	size += ros::serialization::serializationLength(file);
	size += ros::serialization::serializationLength(function);	size += ros::serialization::serializationLength(function);
	size += ros::serialization::serializationLength(line);	size += ros::serialization::serializationLength(line);
	size += ros::serialization::serializationLength(topics);	size += ros::serialization::serializationLength(topics);

End of changes. 11 change blocks.
	25 lines changed or deleted	25 lines changed or added

	common.h	common.h

	skipping to change at line 43	skipping to change at line 43
	#include <stddef.h>	#include <stddef.h>
	#include <string>	#include <string>

	#include "ros/assert.h"	#include "ros/assert.h"
	#include "ros/forwards.h"	#include "ros/forwards.h"
	#include "ros/serialized_message.h"	#include "ros/serialized_message.h"

	#include <boost/shared_array.hpp>	#include <boost/shared_array.hpp>

	#define ROS_VERSION_MAJOR 1	#define ROS_VERSION_MAJOR 1

	#define ROS_VERSION_MINOR 2	#define ROS_VERSION_MINOR 4
	#define ROS_VERSION_PATCH 6	#define ROS_VERSION_PATCH 5
	#define ROS_VERSION_COMBINED(major, minor, patch) (((major) << 20) \| ((mino r) << 10) \| (patch))	#define ROS_VERSION_COMBINED(major, minor, patch) (((major) << 20) \| ((mino r) << 10) \| (patch))
	#define ROS_VERSION ROS_VERSION_COMBINED(ROS_VERSION_MAJOR, ROS_VERSION_MIN OR, ROS_VERSION_PATCH)	#define ROS_VERSION ROS_VERSION_COMBINED(ROS_VERSION_MAJOR, ROS_VERSION_MIN OR, ROS_VERSION_PATCH)

	#define ROS_VERSION_GE(major1, minor1, patch1, major2, minor2, patch2) (ROS _VERSION_COMBINED(major1, minor1, patch1) >= ROS_VERSION_COMBINED(major2, m inor2, patch2))	#define ROS_VERSION_GE(major1, minor1, patch1, major2, minor2, patch2) (ROS _VERSION_COMBINED(major1, minor1, patch1) >= ROS_VERSION_COMBINED(major2, m inor2, patch2))
	#define ROS_VERSION_MINIMUM(major, minor, patch) ROS_VERSION_GE(ROS_VERSION _MAJOR, ROS_VERSION_MINOR, ROS_VERSION_PATCH, major, minor, patch)	#define ROS_VERSION_MINIMUM(major, minor, patch) ROS_VERSION_GE(ROS_VERSION _MAJOR, ROS_VERSION_MINOR, ROS_VERSION_PATCH, major, minor, patch)

	namespace ros	namespace ros
	{	{

	void disableAllSignalsInThisThread();	void disableAllSignalsInThisThread();

End of changes. 1 change blocks.
	2 lines changed or deleted	2 lines changed or added

	debug.h	debug.h

	skipping to change at line 32	skipping to change at line 32
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*/	*/

	#ifndef ROSLIB_DEBUG_H	#ifndef ROSLIB_DEBUG_H
	#define ROSLIB_DEBUG_H	#define ROSLIB_DEBUG_H

	#include <string>	#include <string>

		#include <vector>

	namespace ros	namespace ros
	{	{

	namespace debug	namespace debug
	{	{

		typedef std::vector<void*> V_void;
		typedef std::vector<std::string> V_string;

	std::string getBacktrace();	std::string getBacktrace();

		std::string backtraceToString(const V_void& addresses);
		void getBacktrace(V_void& addresses);
		void translateAddresses(const V_void& addresses, V_string& lines);
		void demangleBacktrace(const V_string& names, V_string& demangled);
		std::string demangleBacktrace(const V_string& names);
		std::string demangleName(const std::string& name);
	}	}

	}	}

	#endif	#endif

End of changes. 3 change blocks.
	0 lines changed or deleted	10 lines changed or added

	duration.h	duration.h

	skipping to change at line 44	skipping to change at line 44

	#ifndef ROS_DURATION_H	#ifndef ROS_DURATION_H
	#define ROS_DURATION_H	#define ROS_DURATION_H

	#include <iostream>	#include <iostream>
	#include <math.h>	#include <math.h>
	#include <stdexcept>	#include <stdexcept>
	#include <climits>	#include <climits>
	#include <stdint.h>	#include <stdint.h>


	#ifdef WIN32
	#include <windows.h>
	#endif

	namespace ros	namespace ros
	{	{

	inline void normalizeSecNSecSigned(int64_t& sec, int64_t& nsec)	inline void normalizeSecNSecSigned(int64_t& sec, int64_t& nsec)
	{	{
	int64_t nsec_part = nsec;	int64_t nsec_part = nsec;
	int64_t sec_part = sec;	int64_t sec_part = sec;

	while (nsec_part > 1000000000L)	while (nsec_part > 1000000000L)
	{	{

End of changes. 1 change blocks.
	4 lines changed or deleted	0 lines changed or added

	forwards.h	forwards.h

	skipping to change at line 42	skipping to change at line 42
	#include <vector>	#include <vector>
	#include <map>	#include <map>
	#include <set>	#include <set>
	#include <list>	#include <list>

	#include <boost/shared_ptr.hpp>	#include <boost/shared_ptr.hpp>
	#include <boost/weak_ptr.hpp>	#include <boost/weak_ptr.hpp>
	#include <boost/function.hpp>	#include <boost/function.hpp>

	#include <ros/time.h>	#include <ros/time.h>

	#include "macros.h"	#include <ros/macros.h>
	#include "exceptions.h"	#include "exceptions.h"

	namespace ros	namespace ros
	{	{

	typedef boost::shared_ptr<void> VoidPtr;	typedef boost::shared_ptr<void> VoidPtr;
	typedef boost::weak_ptr<void> VoidWPtr;	typedef boost::weak_ptr<void> VoidWPtr;
	typedef boost::shared_ptr<void const> VoidConstPtr;	typedef boost::shared_ptr<void const> VoidConstPtr;
	typedef boost::weak_ptr<void const> VoidConstWPtr;	typedef boost::weak_ptr<void const> VoidConstWPtr;


End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	macros.h	macros.h
	/*	/*

	* Copyright (C) 2008, Willow Garage, Inc.	* Copyright (C) 2010, Willow Garage, Inc.
	*	*
	* Redistribution and use in source and binary forms, with or without	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions are m et:	* modification, are permitted provided that the following conditions are m et:
	* * Redistributions of source code must retain the above copyright notic e,	* * Redistributions of source code must retain the above copyright notic e,
	* this list of conditions and the following disclaimer.	* this list of conditions and the following disclaimer.
	* * Redistributions in binary form must reproduce the above copyright	* * Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.	* documentation and/or other materials provided with the distribution.
	* * Neither the names of Willow Garage, Inc. nor the names of its	* * Neither the names of Willow Garage, Inc. nor the names of its
	* contributors may be used to endorse or promote products derived from	* contributors may be used to endorse or promote products derived from

	skipping to change at line 28	skipping to change at line 28
	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE	* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR	* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*/	*/


	#ifndef ROSCPP_MACROS_H	#ifndef ROSLIB_MACROS_H
	#define ROSCPP_MACROS_H	#define ROSLIB_MACROS_H

	#if defined(__GNUC__)	#if defined(__GNUC__)

	#define ROSCPP_DEPRECATED __attribute__((deprecated))	#define ROS_DEPRECATED __attribute__((deprecated))
	#define ROSCPP_FORCEINLINE __attribute__((always_inline))	#define ROS_FORCE_INLINE __attribute__((always_inline))
	#elif defined(MSVC)	#elif defined(MSVC)

	#define ROSCPP_DEPRECATED	#define ROS_DEPRECATED
	#define ROSCPP_FORCEINLINE __forceinline	#define ROS_FORCE_INLINE __forceinline
	#else	#else

	#define ROSCPP_DEPRECATED	#define ROS_DEPRECATED
	#define ROSCPP_FORCEINLINE	#define ROS_FORCE_INLINE inline
	#endif	#endif

	#endif	#endif

End of changes. 5 change blocks.
	9 lines changed or deleted	9 lines changed or added

	message.h	message.h

	skipping to change at line 31	skipping to change at line 31
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*/	*/

	#ifndef ROSCPP_MESSAGE_H	#ifndef ROSCPP_MESSAGE_H
	#define ROSCPP_MESSAGE_H	#define ROSCPP_MESSAGE_H


	#include "macros.h"	#include "ros/macros.h"
	#include "ros/assert.h"	#include "ros/assert.h"
	#include <string>	#include <string>
	#include <string.h>	#include <string.h>
	#include <boost/shared_ptr.hpp>	#include <boost/shared_ptr.hpp>
	#include <boost/array.hpp>	#include <boost/array.hpp>
	#include <stdint.h>	#include <stdint.h>

	#define ROSCPP_MESSAGE_HAS_DEFINITION	#define ROSCPP_MESSAGE_HAS_DEFINITION

	namespace ros	namespace ros
	{	{

	typedef std::map<std::string, std::string> M_string;	typedef std::map<std::string, std::string> M_string;

	/**	/**

	* \brief Base-class for all roscpp messages	* \deprecated This base-class is deprecated in favor of a template-based s erialization and traits system
	*/	*/
	class Message	class Message
	{	{
	public:	public:
	typedef boost::shared_ptr<Message> Ptr;	typedef boost::shared_ptr<Message> Ptr;
	typedef boost::shared_ptr<Message const> ConstPtr;	typedef boost::shared_ptr<Message const> ConstPtr;
	Message()	Message()
	{	{
	}	}
	virtual ~Message()	virtual ~Message()

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	message_event.h	message_event.h

	skipping to change at line 50	skipping to change at line 50
	#include <boost/type_traits/add_const.hpp>	#include <boost/type_traits/add_const.hpp>
	#include <boost/type_traits/remove_const.hpp>	#include <boost/type_traits/remove_const.hpp>
	#include <boost/utility/enable_if.hpp>	#include <boost/utility/enable_if.hpp>
	#include <boost/function.hpp>	#include <boost/function.hpp>
	#include <boost/make_shared.hpp>	#include <boost/make_shared.hpp>

	namespace ros	namespace ros
	{	{

	template<typename M>	template<typename M>

	inline boost::shared_ptr<M> defaultMessageCreateFunction()	struct DefaultMessageCreator
	{	{

	return boost::make_shared<M>();	boost::shared_ptr<M> operator()()
		{
		return boost::make_shared<M>();
		}
		};

		template<typename M>
		ROS_DEPRECATED inline boost::shared_ptr<M> defaultMessageCreateFunction()
		{
		return DefaultMessageCreator<M>()();
	}	}

	/**	/**
	* \brief Event type for subscriptions, const ros::MessageEvent<M const>& c an be used in your callback instead of const boost::shared_ptr<M const>&	* \brief Event type for subscriptions, const ros::MessageEvent<M const>& c an be used in your callback instead of const boost::shared_ptr<M const>&
	*	*
	* Useful if you need to retrieve meta-data about the message, such as the full connection header, or the publisher's node name	* Useful if you need to retrieve meta-data about the message, such as the full connection header, or the publisher's node name
	*/	*/
	template<typename M>	template<typename M>
	class MessageEvent	class MessageEvent
	{	{

	skipping to change at line 106	skipping to change at line 115
	MessageEvent(const MessageEvent<void const>& rhs, const CreateFunction& c reate)	MessageEvent(const MessageEvent<void const>& rhs, const CreateFunction& c reate)
	{	{
	init(boost::const_pointer_cast<Message>(boost::static_pointer_cast<Cons tMessage>(rhs.getMessage())), rhs.getConnectionHeaderPtr(), rhs.getReceiptT ime(), rhs.nonConstWillCopy(), create);	init(boost::const_pointer_cast<Message>(boost::static_pointer_cast<Cons tMessage>(rhs.getMessage())), rhs.getConnectionHeaderPtr(), rhs.getReceiptT ime(), rhs.nonConstWillCopy(), create);
	}	}

	/**	/**
	* \todo Make this explicit in ROS 2.0. Keep as auto-converting for now to maintain backwards compatibility in some places (message_filters)	* \todo Make this explicit in ROS 2.0. Keep as auto-converting for now to maintain backwards compatibility in some places (message_filters)
	*/	*/
	MessageEvent(const ConstMessagePtr& message)	MessageEvent(const ConstMessagePtr& message)
	{	{

	init(message, getConnectionHeader(message.get()), ros::Time::now(), tru e, ros::defaultMessageCreateFunction<Message>);	init(message, getConnectionHeader(message.get()), ros::Time::now(), tru e, ros::DefaultMessageCreator<Message>());
	}	}

	MessageEvent(const ConstMessagePtr& message, const boost::shared_ptr<M_st ring>& connection_header, ros::Time receipt_time)	MessageEvent(const ConstMessagePtr& message, const boost::shared_ptr<M_st ring>& connection_header, ros::Time receipt_time)
	{	{

	init(message, connection_header, receipt_time, true, ros::defaultMessag eCreateFunction<Message>);	init(message, connection_header, receipt_time, true, ros::DefaultMessag eCreator<Message>());
	}	}

	MessageEvent(const ConstMessagePtr& message, ros::Time receipt_time)	MessageEvent(const ConstMessagePtr& message, ros::Time receipt_time)
	{	{

	init(message, getConnectionHeader(message.get()), receipt_time, true, r os::defaultMessageCreateFunction<Message>);	init(message, getConnectionHeader(message.get()), receipt_time, true, r os::DefaultMessageCreator<Message>());
	}	}

	MessageEvent(const ConstMessagePtr& message, const boost::shared_ptr<M_st ring>& connection_header, ros::Time receipt_time, bool nonconst_need_copy, const CreateFunction& create)	MessageEvent(const ConstMessagePtr& message, const boost::shared_ptr<M_st ring>& connection_header, ros::Time receipt_time, bool nonconst_need_copy, const CreateFunction& create)
	{	{
	init(message, connection_header, receipt_time, nonconst_need_copy, crea te);	init(message, connection_header, receipt_time, nonconst_need_copy, crea te);
	}	}

	void init(const ConstMessagePtr& message, const boost::shared_ptr<M_strin g>& connection_header, ros::Time receipt_time, bool nonconst_need_copy, con st CreateFunction& create)	void init(const ConstMessagePtr& message, const boost::shared_ptr<M_strin g>& connection_header, ros::Time receipt_time, bool nonconst_need_copy, con st CreateFunction& create)
	{	{
	message_ = message;	message_ = message;

End of changes. 5 change blocks.
	5 lines changed or deleted	14 lines changed or added

	message_traits.h	message_traits.h

	skipping to change at line 37	skipping to change at line 37

	#ifndef ROSLIB_MESSAGE_TRAITS_H	#ifndef ROSLIB_MESSAGE_TRAITS_H
	#define ROSLIB_MESSAGE_TRAITS_H	#define ROSLIB_MESSAGE_TRAITS_H

	#include "message_forward.h"	#include "message_forward.h"

	#include <ros/time.h>	#include <ros/time.h>

	#include <string>	#include <string>
	#include <boost/utility/enable_if.hpp>	#include <boost/utility/enable_if.hpp>

		#include <boost/type_traits/remove_const.hpp>
		#include <boost/type_traits/remove_reference.hpp>


	namespace roslib	namespace std_msgs
	{	{
	ROS_DECLARE_MESSAGE(Header);	ROS_DECLARE_MESSAGE(Header);
	}	}

	#define ROS_IMPLEMENT_SIMPLE_TOPIC_TRAITS(msg, md5sum, datatype, definition ) \	#define ROS_IMPLEMENT_SIMPLE_TOPIC_TRAITS(msg, md5sum, datatype, definition ) \
	namespace ros \	namespace ros \
	{ \	{ \
	namespace message_traits \	namespace message_traits \
	{ \	{ \
	template<> struct MD5Sum<msg> \	template<> struct MD5Sum<msg> \

	skipping to change at line 163	skipping to change at line 165
	}	}
	};	};

	/**	/**
	* \brief Header trait. In the default implementation pointer()	* \brief Header trait. In the default implementation pointer()
	* returns &m.header if HasHeader<M>::value is true, otherwise returns NULL	* returns &m.header if HasHeader<M>::value is true, otherwise returns NULL
	*/	*/
	template<typename M, typename Enable = void>	template<typename M, typename Enable = void>
	struct Header	struct Header
	{	{

	static roslib::Header* pointer(M& m) { return 0; }	static std_msgs::Header* pointer(M& m) { return 0; }
	static roslib::Header const* pointer(const M& m) { return 0; }	static std_msgs::Header const* pointer(const M& m) { return 0; }
	};	};

	template<typename M>	template<typename M>
	struct Header<M, typename boost::enable_if<HasHeader<M> >::type >	struct Header<M, typename boost::enable_if<HasHeader<M> >::type >
	{	{

	static roslib::Header* pointer(M& m) { return &m.header; }	static std_msgs::Header* pointer(M& m) { return &m.header; }
	static roslib::Header const* pointer(const M& m) { return &m.header; }	static std_msgs::Header const* pointer(const M& m) { return &m.header; }
	};	};

	/**	/**
	* \brief FrameId trait. In the default implementation pointer()	* \brief FrameId trait. In the default implementation pointer()
	* returns &m.header.frame_id if HasHeader<M>::value is true, otherwise ret urns NULL. value()	* returns &m.header.frame_id if HasHeader<M>::value is true, otherwise ret urns NULL. value()
	* does not exist, and causes a compile error	* does not exist, and causes a compile error
	*/	*/
	template<typename M, typename Enable = void>	template<typename M, typename Enable = void>
	struct FrameId	struct FrameId
	{	{

	skipping to change at line 209	skipping to change at line 211
	template<typename M, typename Enable = void>	template<typename M, typename Enable = void>
	struct TimeStamp	struct TimeStamp
	{	{
	static ros::Time* pointer(M& m) { return 0; }	static ros::Time* pointer(M& m) { return 0; }
	static ros::Time const* pointer(const M& m) { return 0; }	static ros::Time const* pointer(const M& m) { return 0; }
	};	};

	template<typename M>	template<typename M>
	struct TimeStamp<M, typename boost::enable_if<HasHeader<M> >::type >	struct TimeStamp<M, typename boost::enable_if<HasHeader<M> >::type >
	{	{

	static ros::Time* pointer(M& m) { return &m.header.stamp; }	static ros::Time* pointer(typename boost::remove_const<M>::type &m) { ret urn &m.header.stamp; }
	static ros::Time const* pointer(const M& m) { return &m.header.stamp; }	static ros::Time const* pointer(const M& m) { return &m.header.stamp; }
	static ros::Time value(const M& m) { return m.header.stamp; }	static ros::Time value(const M& m) { return m.header.stamp; }
	};	};

	/**	/**
	* \brief returns MD5Sum<M>::value();	* \brief returns MD5Sum<M>::value();
	*/	*/
	template<typename M>	template<typename M>
	inline const char* md5sum()	inline const char* md5sum()
	{	{

	return MD5Sum<M>::value();	return MD5Sum<typename boost::remove_reference<typename boost::remove_con st<M>::type>::type>::value();
	}	}

	/**	/**
	* \brief returns DataType<M>::value();	* \brief returns DataType<M>::value();
	*/	*/
	template<typename M>	template<typename M>
	inline const char* datatype()	inline const char* datatype()
	{	{

	return DataType<M>::value();	return DataType<typename boost::remove_reference<typename boost::remove_c onst<M>::type>::type>::value();
	}	}

	/**	/**
	* \brief returns Definition<M>::value();	* \brief returns Definition<M>::value();
	*/	*/
	template<typename M>	template<typename M>
	inline const char* definition()	inline const char* definition()
	{	{

	return Definition<M>::value();	return Definition<typename boost::remove_reference<typename boost::remove _const<M>::type>::type>::value();
	}	}

	/**	/**
	* \brief returns MD5Sum<M>::value(m);	* \brief returns MD5Sum<M>::value(m);
	*/	*/
	template<typename M>	template<typename M>
	inline const char* md5sum(const M& m)	inline const char* md5sum(const M& m)
	{	{

	return MD5Sum<M>::value(m);	return MD5Sum<typename boost::remove_reference<typename boost::remove_con st<M>::type>::type>::value(m);
	}	}

	/**	/**
	* \brief returns DataType<M>::value(m);	* \brief returns DataType<M>::value(m);
	*/	*/
	template<typename M>	template<typename M>
	inline const char* datatype(const M& m)	inline const char* datatype(const M& m)
	{	{

	return DataType<M>::value(m);	return DataType<typename boost::remove_reference<typename boost::remove_c onst<M>::type>::type>::value(m);
	}	}

	/**	/**
	* \brief returns Definition<M>::value(m);	* \brief returns Definition<M>::value(m);
	*/	*/
	template<typename M>	template<typename M>
	inline const char* definition(const M& m)	inline const char* definition(const M& m)
	{	{

	return Definition<M>::value(m);	return Definition<typename boost::remove_reference<typename boost::remove _const<M>::type>::type>::value(m);
	}	}

	/**	/**
	* \brief returns Header<M>::pointer(m);	* \brief returns Header<M>::pointer(m);
	*/	*/
	template<typename M>	template<typename M>

	inline roslib::Header* header(M& m)	inline std_msgs::Header* header(M& m)
	{	{

	return Header<M>::pointer(m);	return Header<typename boost::remove_reference<typename boost::remove_con st<M>::type>::type>::pointer(m);
	}	}

	/**	/**
	* \brief returns Header<M>::pointer(m);	* \brief returns Header<M>::pointer(m);
	*/	*/
	template<typename M>	template<typename M>

	inline roslib::Header const* header(const M& m)	inline std_msgs::Header const* header(const M& m)
	{	{

	return Header<M>::pointer(m);	return Header<typename boost::remove_reference<typename boost::remove_con st<M>::type>::type>::pointer(m);
	}	}

	/**	/**
	* \brief returns FrameId<M>::pointer(m);	* \brief returns FrameId<M>::pointer(m);
	*/	*/
	template<typename M>	template<typename M>
	inline std::string* frameId(M& m)	inline std::string* frameId(M& m)
	{	{

	return FrameId<M>::pointer(m);	return FrameId<typename boost::remove_reference<typename boost::remove_co nst<M>::type>::type>::pointer(m);
	}	}

	/**	/**
	* \brief returns FrameId<M>::pointer(m);	* \brief returns FrameId<M>::pointer(m);
	*/	*/
	template<typename M>	template<typename M>
	inline std::string const* frameId(const M& m)	inline std::string const* frameId(const M& m)
	{	{

	return FrameId<M>::pointer(m);	return FrameId<typename boost::remove_reference<typename boost::remove_co nst<M>::type>::type>::pointer(m);
	}	}

	/**	/**
	* \brief returns TimeStamp<M>::pointer(m);	* \brief returns TimeStamp<M>::pointer(m);
	*/	*/
	template<typename M>	template<typename M>
	inline ros::Time* timeStamp(M& m)	inline ros::Time* timeStamp(M& m)
	{	{

	return TimeStamp<M>::pointer(m);	return TimeStamp<typename boost::remove_reference<typename boost::remove_ const<M>::type>::type>::pointer(m);
	}	}

	/**	/**
	* \brief returns TimeStamp<M>::pointer(m);	* \brief returns TimeStamp<M>::pointer(m);
	*/	*/
	template<typename M>	template<typename M>
	inline ros::Time const* timeStamp(const M& m)	inline ros::Time const* timeStamp(const M& m)
	{	{

	return TimeStamp<M>::pointer(m);	return TimeStamp<typename boost::remove_reference<typename boost::remove_ const<M>::type>::type>::pointer(m);
	}	}

	/**	/**
	* \brief returns IsSimple<M>::value;	* \brief returns IsSimple<M>::value;
	*/	*/
	template<typename M>	template<typename M>
	inline bool isSimple()	inline bool isSimple()
	{	{

	return IsSimple<M>::value;	return IsSimple<typename boost::remove_reference<typename boost::remove_c onst<M>::type>::type>::value;
	}	}

	/**	/**
	* \brief returns IsFixedSize<M>::value;	* \brief returns IsFixedSize<M>::value;
	*/	*/
	template<typename M>	template<typename M>
	inline bool isFixedSize()	inline bool isFixedSize()
	{	{

	return IsFixedSize<M>::value;	return IsFixedSize<typename boost::remove_reference<typename boost::remov e_const<M>::type>::type>::value;
	}	}

	/**	/**
	* \brief returns HasHeader<M>::value;	* \brief returns HasHeader<M>::value;
	*/	*/
	template<typename M>	template<typename M>
	inline bool hasHeader()	inline bool hasHeader()
	{	{

	return HasHeader<M>::value;	return HasHeader<typename boost::remove_reference<typename boost::remove_ const<M>::type>::type>::value;
	}	}

	} // namespace message_traits	} // namespace message_traits
	} // namespace ros	} // namespace ros

	#endif // ROSLIB_MESSAGE_TRAITS_H	#endif // ROSLIB_MESSAGE_TRAITS_H

End of changes. 22 change blocks.
	23 lines changed or deleted	25 lines changed or added

	names.h	names.h

	skipping to change at line 84	skipping to change at line 84
	*/	*/
	std::string remap(const std::string& name);	std::string remap(const std::string& name);
	/**	/**
	* \brief Validate a name against the name spec	* \brief Validate a name against the name spec
	*/	*/
	bool validate(const std::string& name, std::string& error);	bool validate(const std::string& name, std::string& error);

	const M_string& getRemappings();	const M_string& getRemappings();
	const M_string& getUnresolvedRemappings();	const M_string& getUnresolvedRemappings();


		/**
		* \brief Get the parent namespace of a name
		* \param name The namespace of which to get the parent namespace.
		* \throws InvalidNameException if the name passed is not a valid graph res
		ource name
		*/
		std::string parentNamespace(const std::string& name);

	} // namespace names	} // namespace names

	} // namespace ros	} // namespace ros

	#endif // ROSCPP_NAMES_H	#endif // ROSCPP_NAMES_H

End of changes. 1 change blocks.
	0 lines changed or deleted	8 lines changed or added

	publisher.h	publisher.h

	skipping to change at line 80	skipping to change at line 80
	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());
	return;	return;
	}	}

	if (!impl_->isValid())	if (!impl_->isValid())
	{	{
	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());
	return;	return;
	}	}


		ROS_ASSERT_MSG(impl_->md5sum_ != "*" \|\| impl_->md5sum_ == mt::md5sum<M>
		(*message), "Trying to publish message of type [%s/%s] on a publisher with
		type [%s/%s]",
		impl_->datatype_.c_str(), impl_->md5sum_.c_str(), mt::da
		tatype<M>(message), mt::md5sum<M>(message));

	SerializedMessage m;	SerializedMessage m;
	m.type_info = &typeid(M);	m.type_info = &typeid(M);
	m.message = message;	m.message = message;

	publish(boost::bind(serializeMessage<M>, boost::ref(*message)), m);	publish(boost::bind(serializeMessage<M>, boost::ref(*message)), m);
	}	}

	/**	/**
	* \brief Publish a message on the topic associated with this Publisher.	* \brief Publish a message on the topic associated with this Publisher.
	*/	*/
	template<typename M>	template<typename M>
	void publish(const M& message) const	void publish(const M& message) const
	{	{
	using namespace serialization;	using namespace serialization;

		namespace mt = ros::message_traits;

	if (!impl_)	if (!impl_)
	{	{
	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());
	return;	return;
	}	}

	if (!impl_->isValid())	if (!impl_->isValid())
	{	{
	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());	ROS_ASSERT_MSG(false, "Call to publish() on an invalid Publisher (top ic [%s])", impl_->topic_.c_str());
	return;	return;
	}	}


		ROS_ASSERT_MSG(impl_->md5sum_ != "*" \|\| impl_->md5sum_ == mt::md5sum<M>
		(message), "Trying to publish message of type [%s/%s] on a publisher with t
		ype [%s/%s]",
		impl_->datatype_.c_str(), impl_->md5sum_.c_str(), mt::da
		tatype<M>(message), mt::md5sum<M>(message));

	SerializedMessage m;	SerializedMessage m;
	publish(boost::bind(serializeMessage<M>, boost::ref(message)), m);	publish(boost::bind(serializeMessage<M>, boost::ref(message)), m);
	}	}

	/**	/**
	* \brief Shutdown the advertisement associated with this Publisher	* \brief Shutdown the advertisement associated with this Publisher
	*	*
	* This method usually does not need to be explicitly called, as automati c shutdown happens when	* This method usually does not need to be explicitly called, as automati c shutdown happens when
	* all copies of this Publisher go out of scope	* all copies of this Publisher go out of scope
	*	*

	skipping to change at line 156	skipping to change at line 163
	{	{
	return impl_ == rhs.impl_;	return impl_ == rhs.impl_;
	}	}

	bool operator!=(const Publisher& rhs) const	bool operator!=(const Publisher& rhs) const
	{	{
	return impl_ != rhs.impl_;	return impl_ != rhs.impl_;
	}	}

	private:	private:

	Publisher(const std::string& topic, const NodeHandle& node_handle, const SubscriberCallbacksPtr& callbacks);	Publisher(const std::string& topic, const std::string& md5sum, const std: :string& datatype, const NodeHandle& node_handle, const SubscriberCallbacks Ptr& callbacks);

	void publish(const boost::function<SerializedMessage(void)>& serfunc, Ser ializedMessage& m) const;	void publish(const boost::function<SerializedMessage(void)>& serfunc, Ser ializedMessage& m) const;
	void incrementSequence() const;	void incrementSequence() const;

	class Impl	class Impl
	{	{
	public:	public:
	Impl();	Impl();
	~Impl();	~Impl();

	void unadvertise();	void unadvertise();
	bool isValid() const;	bool isValid() const;

	std::string topic_;	std::string topic_;

		std::string md5sum_;
		std::string datatype_;
	NodeHandlePtr node_handle_;	NodeHandlePtr node_handle_;
	SubscriberCallbacksPtr callbacks_;	SubscriberCallbacksPtr callbacks_;
	bool unadvertised_;	bool unadvertised_;
	double constructed_;	double constructed_;
	};	};
	typedef boost::shared_ptr<Impl> ImplPtr;	typedef boost::shared_ptr<Impl> ImplPtr;
	typedef boost::weak_ptr<Impl> ImplWPtr;	typedef boost::weak_ptr<Impl> ImplWPtr;

	ImplPtr impl_;	ImplPtr impl_;


End of changes. 5 change blocks.
	1 lines changed or deleted	16 lines changed or added

	rosout_appender.h	rosout_appender.h

	skipping to change at line 38	skipping to change at line 38
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*/	*/

	#ifndef ROSCPP_ROSOUT_APPENDER_H	#ifndef ROSCPP_ROSOUT_APPENDER_H
	#define ROSCPP_ROSOUT_APPENDER_H	#define ROSCPP_ROSOUT_APPENDER_H


		#include <ros/message_forward.h>

	#include "log4cxx/appenderskeleton.h"	#include "log4cxx/appenderskeleton.h"


	#include <boost/shared_ptr.hpp>	#include <boost/shared_ptr.hpp>
	#include <boost/weak_ptr.hpp>	#include <boost/weak_ptr.hpp>


	#include <roslib/Log.h>
	#include <boost/thread.hpp>	#include <boost/thread.hpp>


		namespace rosgraph_msgs
		{
		ROS_DECLARE_MESSAGE(Log);
		}

	namespace ros	namespace ros
	{	{

	class Publication;	class Publication;
	typedef boost::shared_ptr<Publication> PublicationPtr;	typedef boost::shared_ptr<Publication> PublicationPtr;
	typedef boost::weak_ptr<Publication> PublicationWPtr;	typedef boost::weak_ptr<Publication> PublicationWPtr;

	class ROSOutAppender : public log4cxx::AppenderSkeleton	class ROSOutAppender : public log4cxx::AppenderSkeleton
	{	{
	public:	public:

	skipping to change at line 70	skipping to change at line 77
	protected:	protected:
	virtual void append(const log4cxx::spi::LoggingEventPtr& event, log4cxx:: helpers::Pool& pool);	virtual void append(const log4cxx::spi::LoggingEventPtr& event, log4cxx:: helpers::Pool& pool);

	virtual void close() {}	virtual void close() {}
	virtual bool requiresLayout() const { return false; }	virtual bool requiresLayout() const { return false; }

	void logThread();	void logThread();

	std::string last_error_;	std::string last_error_;


	typedef std::vector<roslib::LogPtr> V_Log;	typedef std::vector<rosgraph_msgs::LogPtr> V_Log;
	V_Log log_queue_;	V_Log log_queue_;
	boost::mutex queue_mutex_;	boost::mutex queue_mutex_;
	boost::condition_variable queue_condition_;	boost::condition_variable queue_condition_;
	bool shutting_down_;	bool shutting_down_;

	boost::thread publish_thread_;	boost::thread publish_thread_;
	};	};

	LOG4CXX_PTR_DEF(ROSOutAppender);	LOG4CXX_PTR_DEF(ROSOutAppender);


End of changes. 5 change blocks.
	2 lines changed or deleted	9 lines changed or added

	rospack.h	rospack.h

	skipping to change at line 135	skipping to change at line 135
	\subsection rospack rospack	\subsection rospack rospack

	%rospack is the command-line tool that provides package management services .	%rospack is the command-line tool that provides package management services .

	%rospack crawls the directory ROS_ROOT and the colon-separated directories	%rospack crawls the directory ROS_ROOT and the colon-separated directories
	in ROS_PACKAGE_PATH, determining a directory to be package if it contains a	in ROS_PACKAGE_PATH, determining a directory to be package if it contains a
	file called @b manifest.xml.	file called @b manifest.xml.

	*/	*/


		#if defined(WIN32)
		#if defined(ROS_STATIC)
		#define ROSPACK_EXPORT
		#elif defined(rospack_EXPORTS)
		#define ROSPACK_EXPORT __declspec(dllexport)
		#else
		#define ROSPACK_EXPORT __declspec(dllimport)
		#endif
		#else
		#define ROSPACK_EXPORT
		#endif

	#include <string>	#include <string>
	#include <vector>	#include <vector>
	#include <list>	#include <list>

	#include "tinyxml-2.5.3/tinyxml.h"	#include "tinyxml-2.5.3/tinyxml.h"

	namespace rospack	namespace rospack
	{	{

	class Package;	class Package;

	skipping to change at line 158	skipping to change at line 170
	extern const char *fs_delim;	extern const char *fs_delim;
	Package *g_get_pkg(const std::string &name);	Package *g_get_pkg(const std::string &name);

	typedef std::vector<Package *> VecPkg;	typedef std::vector<Package *> VecPkg;
	typedef std::list<Package*> Acc;	typedef std::list<Package*> Acc;
	typedef std::list<Acc> AccList;	typedef std::list<Acc> AccList;

	/**	/**
	* The Package class contains information about a single package	* The Package class contains information about a single package
	*/	*/

	class Package	class ROSPACK_EXPORT Package
	{	{
	public:	public:
	enum traversal_order_t { POSTORDER, PREORDER };	enum traversal_order_t { POSTORDER, PREORDER };
	std::string name, path;	std::string name, path;

		// These will cause warnings on Windows when compiling the DLL because th
		ey
		// are static. They should more correctly be accessed via accessor functi
		ons
		// that are exported from the class, rather than directly, in order to
		// "prevent data corruption." Since main.cpp is currently the only known
		// client and it doesn't use them, I'm not caring about the warnings yet.
	static std::vector<Package *> pkgs;	static std::vector<Package *> pkgs;
	static std::vector<Package *> deleted_pkgs;	static std::vector<Package *> deleted_pkgs;

	Package(std::string _path);	Package(std::string _path);
	static bool is_package(std::string path);	static bool is_package(std::string path);
	static bool is_no_subdirs(std::string path);	static bool is_no_subdirs(std::string path);
	const VecPkg &deps1();	const VecPkg &deps1();
	const VecPkg &deps(traversal_order_t order, int depth=0);	const VecPkg &deps(traversal_order_t order, int depth=0);
	std::string manifest_path();	std::string manifest_path();
	std::string flags(std::string lang, std::string attrib);	std::string flags(std::string lang, std::string attrib);

	skipping to change at line 207	skipping to change at line 224
	bool has_parent(std::string pkg);	bool has_parent(std::string pkg);
	const std::vector<Package *> &direct_deps(bool missing_pkg_as_warning=fal se);	const std::vector<Package *> &direct_deps(bool missing_pkg_as_warning=fal se);
	std::string direct_flags(std::string lang, std::string attrib);	std::string direct_flags(std::string lang, std::string attrib);
	void load_manifest();	void load_manifest();
	};	};

	/**	/**
	* The ROSPack class contains information the entire package dependency	* The ROSPack class contains information the entire package dependency
	* tree.	* tree.
	*/	*/

	class ROSPack	class ROSPACK_EXPORT ROSPack
	{	{
	public:	public:
	static const char* usage();	static const char* usage();

	char *ros_root;	char *ros_root;

	ROSPack();	ROSPack();

	~ROSPack();	~ROSPack();


	skipping to change at line 274	skipping to change at line 291
	*/	*/
	int run(int argc, char **argv);	int run(int argc, char **argv);

	// Another form of run, which takes the arguments as a single string.	// Another form of run, which takes the arguments as a single string.
	// WARNING: this method does naive string-splitting on spaces.	// WARNING: this method does naive string-splitting on spaces.
	int run(const std::string& cmd);	int run(const std::string& cmd);

	// Get the accumulated output	// Get the accumulated output
	std::string getOutput() { return output_acc; }	std::string getOutput() { return output_acc; }


		// is -q (quiet) provided ?
		bool is_quiet() { return opt_quiet; }

	int cmd_print_package_list(bool print_path);	int cmd_print_package_list(bool print_path);


		int cmd_list_duplicates();

	int cmd_print_langs_list();	int cmd_print_langs_list();

	void crawl_for_packages(bool force_crawl = false);	void crawl_for_packages(bool force_crawl = false);
	VecPkg partial_crawl(const std::string &path);	VecPkg partial_crawl(const std::string &path);

	// Exposed for testing purposes only	// Exposed for testing purposes only
	std::string deduplicate_tokens(const std::string& s);	std::string deduplicate_tokens(const std::string& s);

	// Storage for --foo options	// Storage for --foo options
	// --deps-only	// --deps-only

	skipping to change at line 305	skipping to change at line 327
	// The package name	// The package name
	std::string opt_package;	std::string opt_package;
	// --target=	// --target=
	std::string opt_target;	std::string opt_target;
	// the number of entries to list in the profile table	// the number of entries to list in the profile table
	int opt_profile_length;	int opt_profile_length;
	// only display zombie directories in profile?	// only display zombie directories in profile?
	bool opt_profile_zombie_only;	bool opt_profile_zombie_only;
	// display warnings about missing dependencies?	// display warnings about missing dependencies?
	bool opt_warn_on_missing_deps;	bool opt_warn_on_missing_deps;

		// display pairs of duplicate packages?
		bool opt_display_duplicate_pkgs;

	private:	private:

		// is quiet
		bool opt_quiet;
	bool cache_lock_failed;	bool cache_lock_failed;
	bool crawled;	bool crawled;
	std::string getCachePath();	std::string getCachePath();

		// Storage for list of path components, used in add_package. We keep it
		// here to avoid reallocation in every run of add_package.
		std::vector<std::string> path_components;
	// Add package, filtering out duplicates.	// Add package, filtering out duplicates.
	Package* add_package(std::string path);	Package* add_package(std::string path);
	/** tests if the cache exists, is new enough, and is valid */	/** tests if the cache exists, is new enough, and is valid */
	bool cache_is_good();	bool cache_is_good();
	/** returns a double representing the seconds since the Epoch */	/** returns a double representing the seconds since the Epoch */
	static double time_since_epoch();	static double time_since_epoch();
	/** remove trailing slashes */	/** remove trailing slashes */
	void sanitize_rppvec(std::vector<std::string> &rppvec);	void sanitize_rppvec(std::vector<std::string> &rppvec);
	// Output accumulates here	// Output accumulates here
	std::string output_acc;	std::string output_acc;
	// A place to store heap-allocated argv, in case we were passed a	// A place to store heap-allocated argv, in case we were passed a
	// std::string in run(). It'll be freed on destruction.	// std::string in run(). It'll be freed on destruction.
	int my_argc;	int my_argc;
	char** my_argv;	char** my_argv;
	void freeArgv();	void freeArgv();
	// Total number of packages found, including duplicates. Used in	// Total number of packages found, including duplicates. Used in
	// determining whether a directory is a zombie.	// determining whether a directory is a zombie.
	int total_num_pkgs;	int total_num_pkgs;

		// Were there any duplicate pkgs found in the crawl?
		bool duplicate_packages_found;
	};	};

	}	}

	#endif	#endif

End of changes. 10 change blocks.
	2 lines changed or deleted	35 lines changed or added

	rosstack.h	rosstack.h

	skipping to change at line 43	skipping to change at line 43
	/**	/**
	\mainpage	\mainpage
	\htmlinclude manifest.html	\htmlinclude manifest.html

	\section overview Overview	\section overview Overview

	\b %rosstack is a ROS dependency and distribution tool. The %rosstack pack age contains	\b %rosstack is a ROS dependency and distribution tool. The %rosstack pack age contains
	a single binary, called \b %rosstack.	a single binary, called \b %rosstack.
	*/	*/


		#if defined(WIN32)
		#if defined(ROS_STATIC)
		#define ROSSTACK_EXPORT
		#elif defined(rosstack_EXPORTS)
		#define ROSSTACK_EXPORT __declspec(dllexport)
		#else
		#define ROSSTACK_EXPORT __declspec(dllimport)
		#endif
		#else
		#define ROSSTACK_EXPORT
		#endif

	#include <string>	#include <string>
	#include <vector>	#include <vector>

	#include "tinyxml-2.5.3/tinyxml.h"	#include "tinyxml-2.5.3/tinyxml.h"
	#include "rospack/rospack.h"	#include "rospack/rospack.h"

	namespace rosstack	namespace rosstack
	{	{


	class Stack;	class ROSSTACK_EXPORT Stack;
	// global helper functions	// global helper functions
	void string_split(const std::string &s, std::vector<std::string> &t, const std::string &d);	void string_split(const std::string &s, std::vector<std::string> &t, const std::string &d);
	bool file_exists(const std::string &fname);	bool file_exists(const std::string &fname);
	extern const char *fs_delim;	extern const char *fs_delim;

		extern const char *path_delim;
	Stack *g_get_stack(const std::string &name);	Stack *g_get_stack(const std::string &name);
	typedef std::vector<Stack *> VecStack;	typedef std::vector<Stack *> VecStack;

	/**	/**
	* The Stack class contains information about a single stack	* The Stack class contains information about a single stack
	*/	*/

	class Stack	class ROSSTACK_EXPORT Stack
	{	{
	public:	public:
	enum traversal_order_t { POSTORDER, PREORDER };	enum traversal_order_t { POSTORDER, PREORDER };
	std::string name, path;	std::string name, path;
	static std::vector<Stack *> stacks;	static std::vector<Stack *> stacks;

	Stack(std::string _path);	Stack(std::string _path);
	static bool is_stack(const std::string &path);	static bool is_stack(const std::string &path);
	static bool is_package(const std::string &path);	static bool is_package(const std::string &path);
	static bool is_no_subdirs(const std::string &path);	static bool is_no_subdirs(const std::string &path);

	skipping to change at line 98	skipping to change at line 111

	bool has_parent(std::string stk);	bool has_parent(std::string stk);
	const VecStack &direct_deps(bool missing_pkg_as_warning=false);	const VecStack &direct_deps(bool missing_pkg_as_warning=false);
	void load_manifest();	void load_manifest();
	};	};

	/**	/**
	* The ROSStack class contains information the entire stack dependency	* The ROSStack class contains information the entire stack dependency
	* tree.	* tree.
	*/	*/

	class ROSStack	class ROSSTACK_EXPORT ROSStack
	{	{
	public:	public:
	static const char* usage();	static const char* usage();
	char *ros_root;	char *ros_root;
	rospack::ROSPack rp;	rospack::ROSPack rp;

	ROSStack();	ROSStack();
	~ROSStack();	~ROSStack();
	Stack *get_stack(const std::string &name);	Stack *get_stack(const std::string &name);
	int cmd_depends_on(bool include_indirect);	int cmd_depends_on(bool include_indirect);

End of changes. 5 change blocks.
	3 lines changed or deleted	16 lines changed or added

	serialization.h	serialization.h

	skipping to change at line 31	skipping to change at line 31
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*/	*/

	#ifndef ROSCPP_SERIALIZATION_H	#ifndef ROSCPP_SERIALIZATION_H
	#define ROSCPP_SERIALIZATION_H	#define ROSCPP_SERIALIZATION_H


	#include "types.h"	#include <ros/types.h>
		#include <ros/time.h>

	#include "serialized_message.h"	#include "serialized_message.h"

	#include "message_traits.h"	#include "ros/message_traits.h"
	#include "builtin_message_traits.h"	#include "ros/builtin_message_traits.h"
	#include "time.h"	#include "ros/exception.h"
	#include "exception.h"	#include "ros/macros.h"
	#include "macros.h"

	#include <vector>	#include <vector>

	#include <boost/array.hpp>	#include <boost/array.hpp>
	#include <boost/call_traits.hpp>	#include <boost/call_traits.hpp>
	#include <boost/utility/enable_if.hpp>	#include <boost/utility/enable_if.hpp>
	#include <boost/mpl/and.hpp>	#include <boost/mpl/and.hpp>
	#include <boost/mpl/or.hpp>	#include <boost/mpl/or.hpp>
	#include <boost/mpl/not.hpp>	#include <boost/mpl/not.hpp>


		#include <cstring>

	#define ROS_NEW_SERIALIZATION_API 1	#define ROS_NEW_SERIALIZATION_API 1

	/**	/**
	* \brief Declare your serializer to use an allInOne member instead of requ iring 3 different serialization	* \brief Declare your serializer to use an allInOne member instead of requ iring 3 different serialization
	* functions.	* functions.
	*	*
	* The allinone method has the form:	* The allinone method has the form:
	\verbatim	\verbatim
	template<typename Stream, typename T>	template<typename Stream, typename T>
	inline static void allInOne(Stream& stream, T t)	inline static void allInOne(Stream& stream, T t)

End of changes. 3 change blocks.
	6 lines changed or deleted	9 lines changed or added

	serialized_message.h	serialized_message.h

	skipping to change at line 31	skipping to change at line 31
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*/	*/

	#ifndef ROSLIB_SERIALIZED_MESSAGE_H	#ifndef ROSLIB_SERIALIZED_MESSAGE_H
	#define ROSLIB_SERIALIZED_MESSAGE_H	#define ROSLIB_SERIALIZED_MESSAGE_H


	#include "types.h"	#include "ros/types.h"

	#include <boost/shared_array.hpp>	#include <boost/shared_array.hpp>
	#include <boost/shared_ptr.hpp>	#include <boost/shared_ptr.hpp>

	namespace ros	namespace ros
	{	{

	class SerializedMessage	class SerializedMessage
	{	{
	public:	public:

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	service_callback_helper.h	service_callback_helper.h

	skipping to change at line 168	skipping to change at line 168
	{	{
	public:	public:
	typedef typename Spec::RequestType RequestType;	typedef typename Spec::RequestType RequestType;
	typedef typename Spec::ResponseType ResponseType;	typedef typename Spec::ResponseType ResponseType;
	typedef typename Spec::RequestPtr RequestPtr;	typedef typename Spec::RequestPtr RequestPtr;
	typedef typename Spec::ResponsePtr ResponsePtr;	typedef typename Spec::ResponsePtr ResponsePtr;
	typedef typename Spec::CallbackType Callback;	typedef typename Spec::CallbackType Callback;
	typedef boost::function<RequestPtr()> ReqCreateFunction;	typedef boost::function<RequestPtr()> ReqCreateFunction;
	typedef boost::function<ResponsePtr()> ResCreateFunction;	typedef boost::function<ResponsePtr()> ResCreateFunction;


	ServiceCallbackHelperT(const Callback& callback, const ReqCreateFunction&	ServiceCallbackHelperT(const Callback& callback,
	create_req = defaultServiceCreateFunction<RequestType>, const ResCreateFun	const ReqCreateFunction& create_req =
	ction& create_res = defaultServiceCreateFunction<ResponseType>)	// these static casts are legally unnecessary, but
		// here to keep clang 2.8 from getting confused
		static_cast<RequestPtr(*)()>(defaultServiceCreateF
		unction<RequestType>),
		const ResCreateFunction& create_res =
		static_cast<ResponsePtr(*)()>(defaultServiceCreate
		Function<ResponseType>))
	: callback_(callback)	: callback_(callback)
	, create_req_(create_req)	, create_req_(create_req)
	, create_res_(create_res)	, create_res_(create_res)
	{	{
	}	}

	virtual bool call(ServiceCallbackHelperCallParams& params)	virtual bool call(ServiceCallbackHelperCallParams& params)
	{	{
	namespace ser = serialization;	namespace ser = serialization;
	RequestPtr req(create_req_());	RequestPtr req(create_req_());

End of changes. 1 change blocks.
	3 lines changed or deleted	9 lines changed or added

	service_traits.h	service_traits.h

	skipping to change at line 31	skipping to change at line 31
	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN	* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)	* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE	* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF T HE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*/	*/

	#ifndef ROSCPP_SERVICE_TRAITS_H	#ifndef ROSCPP_SERVICE_TRAITS_H
	#define ROSCPP_SERVICE_TRAITS_H	#define ROSCPP_SERVICE_TRAITS_H


		#include <boost/type_traits/remove_reference.hpp>
		#include <boost/type_traits/remove_const.hpp>

	namespace ros	namespace ros
	{	{
	namespace service_traits	namespace service_traits
	{	{

	/**	/**
	* \brief Specialize to provide the md5sum for a service	* \brief Specialize to provide the md5sum for a service
	*/	*/
	template<typename M>	template<typename M>
	struct MD5Sum	struct MD5Sum

	skipping to change at line 76	skipping to change at line 79
	return m.__getServiceDataType().c_str();	return m.__getServiceDataType().c_str();
	}	}
	};	};

	/**	/**
	* \brief return MD5Sum<M>::value();	* \brief return MD5Sum<M>::value();
	*/	*/
	template<typename M>	template<typename M>
	inline const char* md5sum()	inline const char* md5sum()
	{	{

	return MD5Sum<M>::value();	return MD5Sum<typename boost::remove_reference<typename boost::remove_con st<M>::type>::type>::value();
	}	}

	/**	/**
	* \brief return DataType<M>::value();	* \brief return DataType<M>::value();
	*/	*/
	template<typename M>	template<typename M>
	inline const char* datatype()	inline const char* datatype()
	{	{

	return DataType<M>::value();	return DataType<typename boost::remove_reference<typename boost::remove_c onst<M>::type>::type>::value();
	}	}

	/**	/**
	* \brief return MD5Sum<M>::value(m);	* \brief return MD5Sum<M>::value(m);
	*/	*/
	template<typename M>	template<typename M>
	inline const char* md5sum(const M& m)	inline const char* md5sum(const M& m)
	{	{

	return MD5Sum<M>::value(m);	return MD5Sum<typename boost::remove_reference<typename boost::remove_con st<M>::type>::type>::value(m);
	}	}

	/**	/**
	* \brief return DataType<M>::value();	* \brief return DataType<M>::value();
	*/	*/
	template<typename M>	template<typename M>
	inline const char* datatype(const M& m)	inline const char* datatype(const M& m)
	{	{

	return DataType<M>::value(m);	return DataType<typename boost::remove_reference<typename boost::remove_c onst<M>::type>::type>::value(m);
	}	}

	} // namespace message_traits	} // namespace message_traits
	} // namespace ros	} // namespace ros

	#endif // ROSCPP_SERVICE_TRAITS_H	#endif // ROSCPP_SERVICE_TRAITS_H

End of changes. 5 change blocks.
	4 lines changed or deleted	7 lines changed or added

	time.h	time.h

	skipping to change at line 38	skipping to change at line 38
	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER	* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE	* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
	* POSSIBILITY OF SUCH DAMAGE.	* POSSIBILITY OF SUCH DAMAGE.
	*********************************************************************/	*********************************************************************/

	#ifndef ROS_TIME_H	#ifndef ROS_TIME_H
	#define ROS_TIME_H	#define ROS_TIME_H


	#include "duration.h"	/*********************************************************************
	#include "exception.h"	** Headers
		*********************************************************************/

	#include <iostream>	#include <iostream>

	#include <math.h>	#include <cmath>
		#include <ros/exception.h>
		#include "duration.h"


	//Ros types also needs to be moved out of roscpp...	/*********************************************************************
	//#include "ros/types.h"	** Cross Platform Headers
		*********************************************************************/

	#ifdef WIN32	#ifdef WIN32

	#include <windows.h>	#include <windows.h>
		#include <sys/timeb.h>
		#else
		#include <sys/time.h>
	#endif	#endif

	namespace ros	namespace ros
	{	{


		/*********************************************************************
		** Exceptions
		*********************************************************************/

		/**
		* @brief Thrown if the ros subsystem hasn't been initialised before use.
		*/
	class TimeNotInitializedException : public Exception	class TimeNotInitializedException : public Exception
	{	{
	public:	public:
	TimeNotInitializedException()	TimeNotInitializedException()

	: Exception("Cannot use ros::Time::now() before the first NodeHandle has been created or ros::start() has been called. "	: Exception("Cannot use ros::Time::now() before the first NodeHand le has been created or ros::start() has been called. "
	"If this is a standalone app or test that just uses ros::Time and does not communicate over ROS, you may also call ros::Time::init()")	"If this is a standalone app or test that just uses ros::Time and does not communicate over ROS, you may also call ros::Time::init()")
	{}	{}
	};	};


		/**
		* @brief Thrown if windoze high perf. timestamping is unavailable.
		*
		* @sa getWallTime
		*/
		class NoHighPerformanceTimersException : public Exception
		{
		public:
		NoHighPerformanceTimersException()
		: Exception("This windows platform does not "
		"support the high-performance timing api.")
		{}
		};

		/*********************************************************************
		** Functions
		*********************************************************************/

	inline void normalizeSecNSec(uint64_t& sec, uint64_t& nsec)	inline void normalizeSecNSec(uint64_t& sec, uint64_t& nsec)
	{	{
	uint64_t nsec_part = nsec % 1000000000UL;	uint64_t nsec_part = nsec % 1000000000UL;
	uint64_t sec_part = nsec / 1000000000UL;	uint64_t sec_part = nsec / 1000000000UL;

	if (sec_part > UINT_MAX)	if (sec_part > UINT_MAX)
	throw std::runtime_error("Time is out of dual 32-bit range");	throw std::runtime_error("Time is out of dual 32-bit range");

	sec += sec_part;	sec += sec_part;
	nsec = nsec_part;	nsec = nsec_part;

	skipping to change at line 109	skipping to change at line 141
	--sec_part;	--sec_part;
	}	}

	if (sec_part < 0 \|\| sec_part > INT_MAX)	if (sec_part < 0 \|\| sec_part > INT_MAX)
	throw std::runtime_error("Time is out of dual 32-bit range");	throw std::runtime_error("Time is out of dual 32-bit range");

	sec = sec_part;	sec = sec_part;
	nsec = nsec_part;	nsec = nsec_part;
	}	}


		/*********************************************************************
		** Time Classes
		*********************************************************************/

	/**	/**
	* \brief Base class for Time implementations. Provides storage, common fu nctions and operator overloads.	* \brief Base class for Time implementations. Provides storage, common fu nctions and operator overloads.
	* This should not need to be used directly.	* This should not need to be used directly.
	*/	*/
	template<class T, class D>	template<class T, class D>
	class TimeBase	class TimeBase
	{	{
	public:	public:
	uint32_t sec, nsec;	uint32_t sec, nsec;


	skipping to change at line 181	skipping to change at line 217
	/**	/**
	* \brief Sleep until a specific time has been reached.	* \brief Sleep until a specific time has been reached.
	*/	*/
	static bool sleepUntil(const Time& end);	static bool sleepUntil(const Time& end);

	static void init();	static void init();
	static void shutdown();	static void shutdown();
	static void setNow(const Time& new_now);	static void setNow(const Time& new_now);
	static bool useSystemTime();	static bool useSystemTime();
	static bool isSimTime();	static bool isSimTime();

		static bool isSystemTime();

	/**	/**
	* \brief Returns whether or not the current time is valid. Time is vali d if it is non-zero.	* \brief Returns whether or not the current time is valid. Time is vali d if it is non-zero.
	*/	*/
	static bool isValid();	static bool isValid();
	/**	/**
	* \brief Wait for time to become valid	* \brief Wait for time to become valid
	*/	*/
	static bool waitForValid();	static bool waitForValid();
	/**	/**

	skipping to change at line 226	skipping to change at line 263

	/**	/**
	* \brief Returns the current wall clock time.	* \brief Returns the current wall clock time.
	*/	*/
	static WallTime now();	static WallTime now();

	/**	/**
	* \brief Sleep until a specific time has been reached.	* \brief Sleep until a specific time has been reached.
	*/	*/
	static bool sleepUntil(const WallTime& end);	static bool sleepUntil(const WallTime& end);


		static bool isSystemTime() { return true; }
	};	};

	std::ostream &operator <<(std::ostream &os, const Time &rhs);	std::ostream &operator <<(std::ostream &os, const Time &rhs);
	std::ostream &operator <<(std::ostream &os, const WallTime &rhs);	std::ostream &operator <<(std::ostream &os, const WallTime &rhs);

	template<class T, class D>	template<class T, class D>
	T& TimeBase<T, D>::fromNSec(uint64_t t)	T& TimeBase<T, D>::fromNSec(uint64_t t)
	{	{
	sec = (int32_t)(t / 1000000000);	sec = (int32_t)(t / 1000000000);
	nsec = (int32_t)(t % 1000000000);	nsec = (int32_t)(t % 1000000000);

End of changes. 10 change blocks.
	7 lines changed or deleted	46 lines changed or added

	timer_manager.h	timer_manager.h

	skipping to change at line 218	skipping to change at line 218
	TimerManager<T, D, E>::TimerManager() :	TimerManager<T, D, E>::TimerManager() :
	new_timer_(false), id_counter_(0), thread_started_(false), quit_(false)	new_timer_(false), id_counter_(0), thread_started_(false), quit_(false)
	{	{

	}	}

	template<class T, class D, class E>	template<class T, class D, class E>
	TimerManager<T, D, E>::~TimerManager()	TimerManager<T, D, E>::~TimerManager()
	{	{
	quit_ = true;	quit_ = true;

		{
		boost::mutex::scoped_lock lock(timers_mutex_);
		timers_cond_.notify_all();
		}
	if (thread_started_)	if (thread_started_)
	{	{
	thread_.join();	thread_.join();
	}	}
	}	}

	template<class T, class D, class E>	template<class T, class D, class E>
	bool TimerManager<T, D, E>::waitingCompare(int32_t lhs, int32_t rhs)	bool TimerManager<T, D, E>::waitingCompare(int32_t lhs, int32_t rhs)
	{	{
	TimerInfoPtr infol = findTimer(lhs);	TimerInfoPtr infol = findTimer(lhs);

	skipping to change at line 312	skipping to change at line 316

	{	{
	boost::mutex::scoped_lock lock(timers_mutex_);	boost::mutex::scoped_lock lock(timers_mutex_);
	timers_.push_back(info);	timers_.push_back(info);

	if (!thread_started_)	if (!thread_started_)
	{	{
	thread_ = boost::thread(boost::bind(&TimerManager::threadFunc, this)) ;	thread_ = boost::thread(boost::bind(&TimerManager::threadFunc, this)) ;
	thread_started_ = true;	thread_started_ = true;
	}	}

	}


	{	{
	boost::mutex::scoped_lock lock(waiting_mutex_);	boost::mutex::scoped_lock lock(waiting_mutex_);
	waiting_.push_back(info->handle);	waiting_.push_back(info->handle);
	waiting_.sort(boost::bind(&TimerManager::waitingCompare, this, _1, _2))	waiting_.sort(boost::bind(&TimerManager::waitingCompare, this, _1, _2
	;	));
	}	}


	new_timer_ = true;	new_timer_ = true;
	timers_cond_.notify_all();	timers_cond_.notify_all();
		}

	return info->handle;	return info->handle;
	}	}

	template<class T, class D, class E>	template<class T, class D, class E>
	void TimerManager<T, D, E>::remove(int32_t handle)	void TimerManager<T, D, E>::remove(int32_t handle)
	{	{
	boost::mutex::scoped_lock lock(timers_mutex_);	boost::mutex::scoped_lock lock(timers_mutex_);

	typename V_TimerInfo::iterator it = timers_.begin();	typename V_TimerInfo::iterator it = timers_.begin();

	skipping to change at line 372	skipping to change at line 376
	if (info->removed)	if (info->removed)
	{	{
	return;	return;
	}	}

	updateNext(info, T::now());	updateNext(info, T::now());
	waiting_.push_back(info->handle);	waiting_.push_back(info->handle);
	waiting_.sort(boost::bind(&TimerManager::waitingCompare, this, _1, _2)) ;	waiting_.sort(boost::bind(&TimerManager::waitingCompare, this, _1, _2)) ;
	}	}


	new_timer_ = true;	{
	timers_cond_.notify_one();	boost::mutex::scoped_lock lock(timers_mutex_);
		new_timer_ = true;
		timers_cond_.notify_one();
		}
	}	}

	template<class T, class D, class E>	template<class T, class D, class E>
	void TimerManager<T, D, E>::updateNext(const TimerManager<T, D, E>::TimerIn foPtr& info, const T& current_time)	void TimerManager<T, D, E>::updateNext(const TimerManager<T, D, E>::TimerIn foPtr& info, const T& current_time)
	{	{
	if (info->oneshot)	if (info->oneshot)
	{	{
	info->next_expected = T(INT_MAX, 999999999);	info->next_expected = T(INT_MAX, 999999999);
	}	}
	else	else

	skipping to change at line 508	skipping to change at line 515
	// detect backwards jumps in time	// detect backwards jumps in time

	if (T::now() < current)	if (T::now() < current)
	{	{
	ROSCPP_LOG_DEBUG("Time jumped backwards, breaking out of sleep");	ROSCPP_LOG_DEBUG("Time jumped backwards, breaking out of sleep");
	break;	break;
	}	}

	current = T::now();	current = T::now();


	timers_cond_.timed_wait(lock, boost::posix_time::milliseconds(1));	if (current >= sleep_end)
		{
		break;
		}

		// If we're on simulation time we need to check now() against sleep_e
		nd more often than on system time,
		// since simulation time may be running faster than real time.
		if (!T::isSystemTime())
		{
		timers_cond_.timed_wait(lock, boost::posix_time::milliseconds(1));
		}
		else
		{
		// On system time we can simply sleep for the rest of the wait time
		, since anything else requiring processing will
		// signal the condition variable
		int32_t remaining_time = std::max((int32_t)((sleep_end - current).t
		oSec() * 1000.0f), 1);
		timers_cond_.timed_wait(lock, boost::posix_time::milliseconds(remai
		ning_time));
		}
	}	}

	new_timer_ = false;	new_timer_ = false;
	}	}
	}	}

	}	}

	#endif	#endif

End of changes. 6 change blocks.
	12 lines changed or deleted	40 lines changed or added

	topic_manager.h	topic_manager.h

	skipping to change at line 45	skipping to change at line 45

	#include "XmlRpcValue.h"	#include "XmlRpcValue.h"

	#include <boost/thread/mutex.hpp>	#include <boost/thread/mutex.hpp>
	#include <boost/thread/recursive_mutex.hpp>	#include <boost/thread/recursive_mutex.hpp>

	namespace ros	namespace ros
	{	{

	class Message;	class Message;

	class SubscribeOptions;	struct SubscribeOptions;
	class AdvertiseOptions;	struct AdvertiseOptions;

	class TopicManager;	class TopicManager;
	typedef boost::shared_ptr<TopicManager> TopicManagerPtr;	typedef boost::shared_ptr<TopicManager> TopicManagerPtr;

	class PollManager;	class PollManager;
	typedef boost::shared_ptr<PollManager> PollManagerPtr;	typedef boost::shared_ptr<PollManager> PollManagerPtr;

	class XMLRPCManager;	class XMLRPCManager;
	typedef boost::shared_ptr<XMLRPCManager> XMLRPCManagerPtr;	typedef boost::shared_ptr<XMLRPCManager> XMLRPCManagerPtr;


	skipping to change at line 184	skipping to change at line 184
	void getBusStats(XmlRpc::XmlRpcValue &stats);	void getBusStats(XmlRpc::XmlRpcValue &stats);

	/** @brief Compute the info for the node's connectivity	/** @brief Compute the info for the node's connectivity
	*	*
	* This is the implementation of the xml-rpc getBusInfo function;	* This is the implementation of the xml-rpc getBusInfo function;
	* it populates the XmlRpcValue object sent to it with various info	* it populates the XmlRpcValue object sent to it with various info
	* about the node's connectivity.	* about the node's connectivity.
	*/	*/
	void getBusInfo(XmlRpc::XmlRpcValue &info);	void getBusInfo(XmlRpc::XmlRpcValue &info);


		/** @brief Return the list of subcriptions for the node
		*
		* This is the implementation of the xml-rpc getSubscriptions
		* function; it populates the XmlRpcValue object sent to it with the
		* list of subscribed topics and their datatypes.
		*/
		void getSubscriptions(XmlRpc::XmlRpcValue &subscriptions);

		/** @brief Return the list of advertised topics for the node
		*
		* This is the implementation of the xml-rpc getPublications
		* function; it populates the XmlRpcValue object sent to it with the
		* list of advertised topics and their datatypes.
		*/
		void getPublications(XmlRpc::XmlRpcValue &publications);

	/** @brief Update local publisher lists.	/** @brief Update local publisher lists.
	*	*
	* Use this method to update address information for publishers on a	* Use this method to update address information for publishers on a
	* given topic.	* given topic.
	*	*
	* @param topic The topic of interest	* @param topic The topic of interest
	* @param pubs The list of publishers to update.	* @param pubs The list of publishers to update.
	*	*
	* @return true on success, false otherwise.	* @return true on success, false otherwise.
	*/	*/
	bool pubUpdate(const std::string &topic, const std::vector<std::string> & pubs);	bool pubUpdate(const std::string &topic, const std::vector<std::string> & pubs);

	void pubUpdateCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);	void pubUpdateCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);
	void requestTopicCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValu e& result);	void requestTopicCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValu e& result);
	void getBusStatsCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue & result);	void getBusStatsCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue & result);
	void getBusInfoCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);	void getBusInfoCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcValue& result);

		void getSubscriptionsCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpc
		Value& result);
		void getPublicationsCallback(XmlRpc::XmlRpcValue& params, XmlRpc::XmlRpcV
		alue& result);

	bool isShuttingDown() { return shutting_down_; }	bool isShuttingDown() { return shutting_down_; }

	boost::mutex subs_mutex_;	boost::mutex subs_mutex_;
	L_Subscription subscriptions_;	L_Subscription subscriptions_;

	boost::recursive_mutex advertised_topics_mutex_;	boost::recursive_mutex advertised_topics_mutex_;
	V_Publication advertised_topics_;	V_Publication advertised_topics_;
	std::list<std::string> advertised_topic_names_;	std::list<std::string> advertised_topic_names_;
	boost::mutex advertised_topic_names_mutex_;	boost::mutex advertised_topic_names_mutex_;

End of changes. 3 change blocks.
	2 lines changed or deleted	22 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/

	console.h	console.h

	skipping to change at line 77	skipping to change at line 77

	namespace boost	namespace boost
	{	{
	template<typename T> class shared_array;	template<typename T> class shared_array;
	}	}

	namespace ros	namespace ros
	{	{
	namespace console	namespace console
	{	{

		void shutdown(); // disables future logging calls

	namespace levels	namespace levels
	{	{
	enum Level	enum Level
	{	{
	Debug,	Debug,
	Info,	Info,
	Warn,	Warn,
	Error,	Error,
	Fatal,	Fatal,

	skipping to change at line 103	skipping to change at line 104
	extern log4cxx::LevelPtr g_level_lookup[];	extern log4cxx::LevelPtr g_level_lookup[];

	/**	/**
	* \brief Only exported because the macros need it. Do not use directly.	* \brief Only exported because the macros need it. Do not use directly.
	*/	*/
	extern bool g_initialized;	extern bool g_initialized;

	/**	/**
	* \brief Don't call this directly. Performs any required initialization/c onfiguration. Happens automatically when using the macro API.	* \brief Don't call this directly. Performs any required initialization/c onfiguration. Happens automatically when using the macro API.
	*	*

	* If you're going to be using log4cxx or any of the ros::console functions , and need the system to be initialized, use the	* If you're going to be using log4cxx or any of the ::ros::console functio ns, and need the system to be initialized, use the
	* ROSCONSOLE_AUTOINIT macro.	* ROSCONSOLE_AUTOINIT macro.
	*/	*/
	void initialize();	void initialize();


	struct FilterBase;	class FilterBase;
	/**	/**
	* \brief Don't call this directly. Use the ROS_LOG() macro instead.	* \brief Don't call this directly. Use the ROS_LOG() macro instead.
	* @param level Logging level	* @param level Logging level
	* @param file File this logging statement is from (usually generated with __FILE__)	* @param file File this logging statement is from (usually generated with __FILE__)
	* @param line Line of code this logging statement is from (usually generat ed with __LINE__)	* @param line Line of code this logging statement is from (usually generat ed with __LINE__)
	* @param fmt Format string	* @param fmt Format string
	*/	*/
	void print(FilterBase* filter, log4cxx::Logger* logger, Level level, const char* file, int line, const char* function, const char* fmt, ...) ROSCONSOL E_PRINTF_ATTRIBUTE(7, 8);	void print(FilterBase* filter, log4cxx::Logger* logger, Level level, const char* file, int line, const char* function, const char* fmt, ...) ROSCONSOL E_PRINTF_ATTRIBUTE(7, 8);

	void print(FilterBase* filter, log4cxx::Logger* logger, Level level, const std::stringstream& str, const char* file, int line, const char* function);	void print(FilterBase* filter, log4cxx::Logger* logger, Level level, const std::stringstream& str, const char* file, int line, const char* function);

	skipping to change at line 220	skipping to change at line 221
	*/	*/
	void checkLogLocationEnabled(LogLocation* loc);	void checkLogLocationEnabled(LogLocation* loc);

	/**	/**
	* \brief Internal	* \brief Internal
	*/	*/
	struct LogLocation	struct LogLocation
	{	{
	bool initialized_;	bool initialized_;
	bool logger_enabled_;	bool logger_enabled_;

	ros::console::Level level_;	::ros::console::Level level_;
	log4cxx::Logger* logger_;	log4cxx::Logger* logger_;
	};	};

	void vformatToBuffer(boost::shared_array<char>& buffer, size_t& buffer_size , const char* fmt, va_list args);	void vformatToBuffer(boost::shared_array<char>& buffer, size_t& buffer_size , const char* fmt, va_list args);
	void formatToBuffer(boost::shared_array<char>& buffer, size_t& buffer_size, const char* fmt, ...);	void formatToBuffer(boost::shared_array<char>& buffer, size_t& buffer_size, const char* fmt, ...);
	std::string formatToString(const char* fmt, ...);	std::string formatToString(const char* fmt, ...);

	} // namespace console	} // namespace console
	} // namespace ros	} // namespace ros


	skipping to change at line 281	skipping to change at line 282
	#define ROSCONSOLE_MIN_SEVERITY ROSCONSOLE_SEVERITY_DEBUG	#define ROSCONSOLE_MIN_SEVERITY ROSCONSOLE_SEVERITY_DEBUG
	#endif	#endif

	/**	/**
	* \def ROSCONSOLE_AUTOINIT	* \def ROSCONSOLE_AUTOINIT
	* \brief Initializes the rosconsole library. Usually unnecessary to call directly.	* \brief Initializes the rosconsole library. Usually unnecessary to call directly.
	*/	*/
	#define ROSCONSOLE_AUTOINIT \	#define ROSCONSOLE_AUTOINIT \
	do \	do \
	{ \	{ \

	if (ROS_UNLIKELY(!ros::console::g_initialized)) \	if (ROS_UNLIKELY(!::ros::console::g_initialized)) \
	{ \	{ \

	ros::console::initialize(); \	::ros::console::initialize(); \
	} \	} \
	} while(0)	} while(0)

	#define ROSCONSOLE_DEFINE_LOCATION(cond, level, name) \	#define ROSCONSOLE_DEFINE_LOCATION(cond, level, name) \
	ROSCONSOLE_AUTOINIT; \	ROSCONSOLE_AUTOINIT; \

	static ros::console::LogLocation loc = {false, false, ros::console::level s::Count, 0}; /* Initialized at compile-time */ \	static ::ros::console::LogLocation loc = {false, false, ::ros::console::l evels::Count, 0}; /* Initialized at compile-time */ \
	if (ROS_UNLIKELY(!loc.initialized_)) \	if (ROS_UNLIKELY(!loc.initialized_)) \
	{ \	{ \
	initializeLogLocation(&loc, name, level); \	initializeLogLocation(&loc, name, level); \
	} \	} \
	if (ROS_UNLIKELY(loc.level_ != level)) \	if (ROS_UNLIKELY(loc.level_ != level)) \
	{ \	{ \
	setLogLocationLevel(&loc, level); \	setLogLocationLevel(&loc, level); \
	checkLogLocationEnabled(&loc); \	checkLogLocationEnabled(&loc); \
	} \	} \
	bool enabled = loc.logger_enabled_ && (cond);	bool enabled = loc.logger_enabled_ && (cond);

	#define ROSCONSOLE_PRINT_AT_LOCATION_WITH_FILTER(filter, ...) \	#define ROSCONSOLE_PRINT_AT_LOCATION_WITH_FILTER(filter, ...) \

	ros::console::print(filter, loc.logger_, loc.level_, __FILE__, __LINE__ , __ROSCONSOLE_FUNCTION__, __VA_ARGS__)	::ros::console::print(filter, loc.logger_, loc.level_, __FILE__, __LINE __, __ROSCONSOLE_FUNCTION__, __VA_ARGS__)

	#define ROSCONSOLE_PRINT_AT_LOCATION(...) \	#define ROSCONSOLE_PRINT_AT_LOCATION(...) \
	ROSCONSOLE_PRINT_AT_LOCATION_WITH_FILTER(0, __VA_ARGS__)	ROSCONSOLE_PRINT_AT_LOCATION_WITH_FILTER(0, __VA_ARGS__)

	#define ROSCONSOLE_PRINT_STREAM_AT_LOCATION_WITH_FILTER(filter, args) \	#define ROSCONSOLE_PRINT_STREAM_AT_LOCATION_WITH_FILTER(filter, args) \
	do \	do \
	{ \	{ \
	std::stringstream ss; \	std::stringstream ss; \
	ss << args; \	ss << args; \

	ros::console::print(filter, loc.logger_, loc.level_, ss, __FILE__, __LI NE__, __ROSCONSOLE_FUNCTION__); \	::ros::console::print(filter, loc.logger_, loc.level_, ss, __FILE__, __ LINE__, __ROSCONSOLE_FUNCTION__); \
	} while (0)	} while (0)

	#define ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args) \	#define ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args) \
	ROSCONSOLE_PRINT_STREAM_AT_LOCATION_WITH_FILTER(0, args)	ROSCONSOLE_PRINT_STREAM_AT_LOCATION_WITH_FILTER(0, args)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, only if a given condition has been met, with printf-style formatting	* \brief Log to a given named logger at a given verbosity level, only if a given condition has been met, with printf-style formatting
	*	*
	* \note The condition will only be evaluated if this logging statement is enabled	* \note The condition will only be evaluated if this logging statement is enabled
	*	*
	* \param cond Boolean condition to be evaluated	* \param cond Boolean condition to be evaluated

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG_COND(cond, level, name, ...) \	#define ROS_LOG_COND(cond, level, name, ...) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(cond, level, name); \	ROSCONSOLE_DEFINE_LOCATION(cond, level, name); \
	\	\
	if (ROS_UNLIKELY(enabled)) \	if (ROS_UNLIKELY(enabled)) \
	{ \	{ \
	ROSCONSOLE_PRINT_AT_LOCATION(__VA_ARGS__); \	ROSCONSOLE_PRINT_AT_LOCATION(__VA_ARGS__); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, only if a given condition has been met, with stream-style formatting	* \brief Log to a given named logger at a given verbosity level, only if a given condition has been met, with stream-style formatting
	*	*
	* \note The condition will only be evaluated if this logging statement is enabled	* \note The condition will only be evaluated if this logging statement is enabled
	*	*
	* \param cond Boolean condition to be evaluated	* \param cond Boolean condition to be evaluated

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG_STREAM_COND(cond, level, name, args) \	#define ROS_LOG_STREAM_COND(cond, level, name, args) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(cond, level, name); \	ROSCONSOLE_DEFINE_LOCATION(cond, level, name); \
	if (ROS_UNLIKELY(enabled)) \	if (ROS_UNLIKELY(enabled)) \
	{ \	{ \
	ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args); \	ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, only the first time it is hit when enabled, with printf-style formatting	* \brief Log to a given named logger at a given verbosity level, only the first time it is hit when enabled, with printf-style formatting
	*	*

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG_ONCE(level, name, ...) \	#define ROS_LOG_ONCE(level, name, ...) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \
	static bool hit = false; \	static bool hit = false; \
	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(!hit)) \	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(!hit)) \
	{ \	{ \
	hit = true; \	hit = true; \
	ROSCONSOLE_PRINT_AT_LOCATION(__VA_ARGS__); \	ROSCONSOLE_PRINT_AT_LOCATION(__VA_ARGS__); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, only the first time it is hit when enabled, with printf-style formatting	* \brief Log to a given named logger at a given verbosity level, only the first time it is hit when enabled, with printf-style formatting
	*	*

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG_STREAM_ONCE(level, name, args) \	#define ROS_LOG_STREAM_ONCE(level, name, args) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \
	static bool hit = false; \	static bool hit = false; \
	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(!hit)) \	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(!hit)) \
	{ \	{ \
	hit = true; \	hit = true; \
	ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args); \	ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, limited t o a specific rate of printing, with printf-style formatting	* \brief Log to a given named logger at a given verbosity level, limited t o a specific rate of printing, with printf-style formatting
	*	*

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	* \param rate The rate it should actually trigger at	* \param rate The rate it should actually trigger at
	*/	*/
	#define ROS_LOG_THROTTLE(rate, level, name, ...) \	#define ROS_LOG_THROTTLE(rate, level, name, ...) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \
	static double last_hit = 0.0; \	static double last_hit = 0.0; \

	ros::Time now = ros::Time::now(); \	::ros::Time now = ::ros::Time::now(); \
	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(last_hit + rate <= now.toSec( ))) \	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(last_hit + rate <= now.toSec( ))) \
	{ \	{ \
	last_hit = now.toSec(); \	last_hit = now.toSec(); \
	ROSCONSOLE_PRINT_AT_LOCATION(__VA_ARGS__); \	ROSCONSOLE_PRINT_AT_LOCATION(__VA_ARGS__); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, limited t o a specific rate of printing, with printf-style formatting	* \brief Log to a given named logger at a given verbosity level, limited t o a specific rate of printing, with printf-style formatting
	*	*

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	* \param rate The rate it should actually trigger at	* \param rate The rate it should actually trigger at
	*/	*/
	#define ROS_LOG_STREAM_THROTTLE(rate, level, name, args) \	#define ROS_LOG_STREAM_THROTTLE(rate, level, name, args) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \
	static double last_hit = 0.0; \	static double last_hit = 0.0; \

	ros::Time now = ros::Time::now(); \	::ros::Time now = ::ros::Time::now(); \
	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(last_hit + rate <= now.toSec( ))) \	if (ROS_UNLIKELY(enabled) && ROS_UNLIKELY(last_hit + rate <= now.toSec( ))) \
	{ \	{ \
	last_hit = now.toSec(); \	last_hit = now.toSec(); \
	ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args); \	ROSCONSOLE_PRINT_STREAM_AT_LOCATION(args); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, with user -defined filtering, with printf-style formatting	* \brief Log to a given named logger at a given verbosity level, with user -defined filtering, with printf-style formatting
	*	*
	* \param filter pointer to the filter to be used	* \param filter pointer to the filter to be used

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG_FILTER(filter, level, name, ...) \	#define ROS_LOG_FILTER(filter, level, name, ...) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \
	if (ROS_UNLIKELY(enabled) && (filter)->isEnabled()) \	if (ROS_UNLIKELY(enabled) && (filter)->isEnabled()) \
	{ \	{ \
	ROSCONSOLE_PRINT_AT_LOCATION_WITH_FILTER(filter, __VA_ARGS__); \	ROSCONSOLE_PRINT_AT_LOCATION_WITH_FILTER(filter, __VA_ARGS__); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, with user -defined filtering, with stream-style formatting	* \brief Log to a given named logger at a given verbosity level, with user -defined filtering, with stream-style formatting
	*	*
	* \param cond Boolean condition to be evaluated	* \param cond Boolean condition to be evaluated

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG_STREAM_FILTER(filter, level, name, args) \	#define ROS_LOG_STREAM_FILTER(filter, level, name, args) \
	do \	do \
	{ \	{ \
	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \	ROSCONSOLE_DEFINE_LOCATION(true, level, name); \
	if (ROS_UNLIKELY(enabled) && (filter)->isEnabled()) \	if (ROS_UNLIKELY(enabled) && (filter)->isEnabled()) \
	{ \	{ \
	ROSCONSOLE_PRINT_STREAM_AT_LOCATION_WITH_FILTER(filter, args); \	ROSCONSOLE_PRINT_STREAM_AT_LOCATION_WITH_FILTER(filter, args); \
	} \	} \
	} while(0)	} while(0)

	/**	/**
	* \brief Log to a given named logger at a given verbosity level, with prin tf-style formatting	* \brief Log to a given named logger at a given verbosity level, with prin tf-style formatting
	*	*

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG(level, name, ...) ROS_LOG_COND(true, level, name, __VA_ARGS __)	#define ROS_LOG(level, name, ...) ROS_LOG_COND(true, level, name, __VA_ARGS __)
	/**	/**
	* \brief Log to a given named logger at a given verbosity level, with stre am-style formatting	* \brief Log to a given named logger at a given verbosity level, with stre am-style formatting
	*	*

	* \param level One of the levels specified in ros::console::levels::Level	* \param level One of the levels specified in ::ros::console::levels::Leve l
	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.	* \param name Name of the logger. Note that this is the fully qualified n ame, and does NOT include "ros.<package_name>". Use ROSCONSOLE_DEFAULT_NAM E if you would like to use the default name.
	*/	*/
	#define ROS_LOG_STREAM(level, name, args) ROS_LOG_STREAM_COND(true, level, name, args)	#define ROS_LOG_STREAM(level, name, args) ROS_LOG_STREAM_COND(true, level, name, args)

	#include "rosconsole/macros_generated.h"	#include "rosconsole/macros_generated.h"

	#endif // ROSCONSOLE_ROSCONSOLE_H	#endif // ROSCONSOLE_ROSCONSOLE_H

End of changes. 21 change blocks.
	20 lines changed or deleted	21 lines changed or added

	subscribe_options.h	subscribe_options.h

	skipping to change at line 83	skipping to change at line 83
	* \brief Templated initialization, templated on callback parameter type. Supports any callback parameters supported by the SubscriptionCallbackAda pter	* \brief Templated initialization, templated on callback parameter type. Supports any callback parameters supported by the SubscriptionCallbackAda pter
	* \param _topic Topic to subscribe on	* \param _topic Topic to subscribe on
	* \param _queue_size Number of incoming messages to queue up for	* \param _queue_size Number of incoming messages to queue up for
	* processing (messages in excess of this queue capacity will be	* processing (messages in excess of this queue capacity will be
	* discarded).	* discarded).
	* \param _callback Callback to call when a message arrives on this topic	* \param _callback Callback to call when a message arrives on this topic
	*/	*/
	template<class P>	template<class P>
	void initByFullCallbackType(const std::string& _topic, uint32_t _queue_si ze,	void initByFullCallbackType(const std::string& _topic, uint32_t _queue_si ze,
	const boost::function<void (P)>& _callback,	const boost::function<void (P)>& _callback,

	const boost::function<boost::shared_ptr<typename ParameterAdapter<P> ::Message>(void)>& factory_fn = defaultMessageCreateFunction<typename Param eterAdapter<P>::Message>)	const boost::function<boost::shared_ptr<typename ParameterAdapter<P> ::Message>(void)>& factory_fn = DefaultMessageCreator<typename ParameterAda pter<P>::Message>())
	{	{
	typedef typename ParameterAdapter<P>::Message MessageType;	typedef typename ParameterAdapter<P>::Message MessageType;
	topic = _topic;	topic = _topic;
	queue_size = _queue_size;	queue_size = _queue_size;
	md5sum = message_traits::md5sum<MessageType>();	md5sum = message_traits::md5sum<MessageType>();
	datatype = message_traits::datatype<MessageType>();	datatype = message_traits::datatype<MessageType>();
	helper = SubscriptionCallbackHelperPtr(new SubscriptionCallbackHelperT< P>(_callback, factory_fn));	helper = SubscriptionCallbackHelperPtr(new SubscriptionCallbackHelperT< P>(_callback, factory_fn));
	}	}

	/**	/**
	* \brief Templated initialization, templated on message type. Only supp orts "const boost::shared_ptr<M const>&" callback types	* \brief Templated initialization, templated on message type. Only supp orts "const boost::shared_ptr<M const>&" callback types
	* \param _topic Topic to subscribe on	* \param _topic Topic to subscribe on
	* \param _queue_size Number of incoming messages to queue up for	* \param _queue_size Number of incoming messages to queue up for
	* processing (messages in excess of this queue capacity will be	* processing (messages in excess of this queue capacity will be
	* discarded).	* discarded).
	* \param _callback Callback to call when a message arrives on this topic	* \param _callback Callback to call when a message arrives on this topic
	*/	*/
	template<class M>	template<class M>
	void init(const std::string& _topic, uint32_t _queue_size,	void init(const std::string& _topic, uint32_t _queue_size,
	const boost::function<void (const boost::shared_ptr<M const>&)>& _ca llback,	const boost::function<void (const boost::shared_ptr<M const>&)>& _ca llback,

	const boost::function<boost::shared_ptr<M>(void)>& factory_fn = defa ultMessageCreateFunction<M>)	const boost::function<boost::shared_ptr<M>(void)>& factory_fn = Defa ultMessageCreator<M>())
	{	{
	typedef typename ParameterAdapter<M>::Message MessageType;	typedef typename ParameterAdapter<M>::Message MessageType;
	topic = _topic;	topic = _topic;
	queue_size = _queue_size;	queue_size = _queue_size;
	md5sum = message_traits::md5sum<MessageType>();	md5sum = message_traits::md5sum<MessageType>();
	datatype = message_traits::datatype<MessageType>();	datatype = message_traits::datatype<MessageType>();
	helper = SubscriptionCallbackHelperPtr(new SubscriptionCallbackHelperT< const boost::shared_ptr<MessageType const>&>(_callback, factory_fn));	helper = SubscriptionCallbackHelperPtr(new SubscriptionCallbackHelperT< const boost::shared_ptr<MessageType const>&>(_callback, factory_fn));
	}	}

	std::string topic; ///< To pic to subscribe to	std::string topic; ///< To pic to subscribe to

End of changes. 2 change blocks.
	2 lines changed or deleted	2 lines changed or added

	subscription_callback_helper.h	subscription_callback_helper.h

	skipping to change at line 135	skipping to change at line 135
	typedef typename ParameterAdapter<P>::Event Event;	typedef typename ParameterAdapter<P>::Event Event;
	typedef typename boost::add_const<NonConstType>::type ConstType;	typedef typename boost::add_const<NonConstType>::type ConstType;
	typedef boost::shared_ptr<NonConstType> NonConstTypePtr;	typedef boost::shared_ptr<NonConstType> NonConstTypePtr;
	typedef boost::shared_ptr<ConstType> ConstTypePtr;	typedef boost::shared_ptr<ConstType> ConstTypePtr;

	static const bool is_const = ParameterAdapter<P>::is_const;	static const bool is_const = ParameterAdapter<P>::is_const;

	typedef boost::function<void(typename Adapter::Parameter)> Callback;	typedef boost::function<void(typename Adapter::Parameter)> Callback;
	typedef boost::function<NonConstTypePtr()> CreateFunction;	typedef boost::function<NonConstTypePtr()> CreateFunction;


	SubscriptionCallbackHelperT(const Callback& callback, const CreateFunctio n& create = defaultMessageCreateFunction<NonConstType>)	SubscriptionCallbackHelperT(const Callback& callback, const CreateFunctio n& create = DefaultMessageCreator<NonConstType>())
	: callback_(callback)	: callback_(callback)
	, create_(create)	, create_(create)
	{}	{}

	void setCreateFunction(const CreateFunction& create)	void setCreateFunction(const CreateFunction& create)
	{	{
	create_ = create;	create_ = create;
	}	}

	virtual VoidConstPtr deserialize(const SubscriptionCallbackHelperDeserial izeParams& params)	virtual VoidConstPtr deserialize(const SubscriptionCallbackHelperDeserial izeParams& params)

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added