Merge branch 'toolchain-2.9' into fix-rtt_roscomm-rosservice-namespace

Author: meyerj

rtt_dynamic_reconfigure/include/orocos/rtt_dynamic_reconfigure/server.h

@@ -74,8 +74,8 @@ typedef void (NotifyCallbackSignature)(uint32_t level);
  */
 template <class ConfigType>
 struct Updater {
-    virtual bool propertiesFromConfig(ConfigType &config, uint32_t level, RTT::PropertyBag &) { return false; }
-    virtual bool configFromProperties(ConfigType &config, const RTT::PropertyBag &) { return false; }
+    virtual bool propertiesFromConfig(ConfigType &, uint32_t, RTT::PropertyBag &) { return false; }
+    virtual bool configFromProperties(ConfigType &, const RTT::PropertyBag &) { return false; }
 };
 
 template <class ConfigType>

rtt_roscomm/include/rtt_roscomm/rtt_rosservice_proxy.h

@@ -7,6 +7,9 @@
 #include <rtt/internal/GlobalEngine.hpp>
 #include <rtt/plugin/ServicePlugin.hpp>
 
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_void.hpp>
+
 namespace rtt_roscomm {
 
 //! Abstract ROS Service Proxy
@@ -48,7 +51,9 @@ class ROSServiceServerOperationCallerBase {
 };
 
 template<class ROS_SERVICE_T, int variant = 0>
-struct ROSServiceServerOperationCallerWrapper;
+struct ROSServiceServerOperationCallerWrapper {
+  typedef void ProxyOperationCallerType;
+};
 
 // Default implementation of an OperationCaller that fowards ROS service calls to Orocos operations
 // that have the default bool(Request&, Response&) signature. You can add more variants of this class
@@ -68,7 +73,7 @@ struct ROSServiceServerOperationCallerWrapper<ROS_SERVICE_T,0> {
 template<class ROS_SERVICE_T, int variant = 0>
 class ROSServiceServerOperationCaller : public ROSServiceServerOperationCallerBase<ROS_SERVICE_T> {
 public:
-  using typename ROSServiceServerOperationCallerBase<ROS_SERVICE_T>::Ptr;
+  typedef typename ROSServiceServerOperationCallerBase<ROS_SERVICE_T>::Ptr Ptr;
 
   //! The wrapper type for this variant
   typedef ROSServiceServerOperationCallerWrapper<ROS_SERVICE_T, variant> Wrapper;
@@ -77,14 +82,7 @@ class ROSServiceServerOperationCaller : public ROSServiceServerOperationCallerBa
   typedef typename Wrapper::ProxyOperationCallerType ProxyOperationCallerType;
   typedef boost::shared_ptr<ProxyOperationCallerType> ProxyOperationCallerTypePtr;
 
-  static Ptr connect(RTT::OperationInterfacePart* operation) {
-    ProxyOperationCallerTypePtr proxy_operation_caller
-        = boost::make_shared<ProxyOperationCallerType>(operation->getLocalOperation(), RTT::internal::GlobalEngine::Instance());
-    if (proxy_operation_caller->ready()) {
-      return Ptr(new ROSServiceServerOperationCaller<ROS_SERVICE_T, variant>(proxy_operation_caller));
-    }
-    return NextVariant<void>::connect(operation);
-  }
+  static Ptr connect(RTT::OperationInterfacePart* operation);
 
   virtual bool call(typename ROS_SERVICE_T::Request& request, typename ROS_SERVICE_T::Response& response) const {
     // Check if the operation caller is ready, and then call it.
@@ -93,32 +91,41 @@ class ROSServiceServerOperationCaller : public ROSServiceServerOperationCallerBa
   }
 
 private:
-  template<typename Dummy> struct Void { typedef void type; };
+  ROSServiceServerOperationCaller(const boost::shared_ptr<ProxyOperationCallerType>& impl)
+      : proxy_operation_caller_(impl) {}
 
-  template<typename R = void, typename Enabled = void> struct EnableIfHasNextVariant { };
+  ProxyOperationCallerTypePtr proxy_operation_caller_;
+};
 
-  template<typename R> struct EnableIfHasNextVariant<R,
-      typename Void<typename ROSServiceServerOperationCallerWrapper<ROS_SERVICE_T, variant + 1>::ProxyOperationCallerType>::type> {
-    typedef R type;
-  };
+namespace {
 
-  template<typename R = void, typename Enabled = void>
-  struct NextVariant {
-    static Ptr connect(RTT::OperationInterfacePart*) { return Ptr(); }
-  };
+template<class ROS_SERVICE_T, int variant, typename Enabled = void>
+struct ROSServiceServerOperationCallerWrapperNextVariant {
+  typedef typename ROSServiceServerOperationCallerBase<ROS_SERVICE_T>::Ptr Ptr;
+  static Ptr connect(RTT::OperationInterfacePart*) { return Ptr(); }
+};
 
-  template<typename R>
-  struct NextVariant<R, typename EnableIfHasNextVariant<R>::type> {
-    static Ptr connect(RTT::OperationInterfacePart* operation) {
-      return ROSServiceServerOperationCaller<ROS_SERVICE_T, variant + 1>::connect(operation);
-    }
-  };
+template<class ROS_SERVICE_T, int variant>
+struct ROSServiceServerOperationCallerWrapperNextVariant<ROS_SERVICE_T, variant,
+    typename boost::disable_if<boost::is_void<typename ROSServiceServerOperationCallerWrapper<ROS_SERVICE_T, variant + 1>::ProxyOperationCallerType> >::type> {
+  typedef typename ROSServiceServerOperationCallerBase<ROS_SERVICE_T>::Ptr Ptr;
+  static Ptr connect(RTT::OperationInterfacePart* operation) {
+    return ROSServiceServerOperationCaller<ROS_SERVICE_T, variant + 1>::connect(operation);
+  }
+};
 
-  ROSServiceServerOperationCaller(const boost::shared_ptr<ProxyOperationCallerType>& impl)
-      : proxy_operation_caller_(impl) {}
+}
 
-  ProxyOperationCallerTypePtr proxy_operation_caller_;
-};
+template<class ROS_SERVICE_T, int variant>
+typename ROSServiceServerOperationCaller<ROS_SERVICE_T, variant>::Ptr
+ROSServiceServerOperationCaller<ROS_SERVICE_T, variant>::connect(RTT::OperationInterfacePart* operation) {
+  ProxyOperationCallerTypePtr proxy_operation_caller
+      = boost::make_shared<ProxyOperationCallerType>(operation->getLocalOperation(), RTT::internal::GlobalEngine::Instance());
+  if (proxy_operation_caller->ready()) {
+    return Ptr(new ROSServiceServerOperationCaller<ROS_SERVICE_T, variant>(proxy_operation_caller));
+  }
+  return ROSServiceServerOperationCallerWrapperNextVariant<ROS_SERVICE_T, variant>::connect(operation);
+}
 
 template<class ROS_SERVICE_T>
 class ROSServiceServerProxy : public ROSServiceServerProxyBase

rtt_roscomm/src/templates/service/CMakeLists.txt

@@ -6,8 +6,6 @@ else()
   #add_definitions( -DRTT_COMPONENT )
 endif()
 
-include(AddFileDependencies)
-
 # Configure source and destination paths of generated files
 rtt_roscomm_destinations()
 
@@ -89,8 +87,6 @@ configure_file(
   rtt_rosservice_proxies.cpp.in
   ${CMAKE_CURRENT_BINARY_DIR}/rtt_rosservice_proxies.cpp @ONLY )
 
-add_file_dependencies( ${CMAKE_CURRENT_BINARY_DIR}/rtt_rosservice_proxies.cpp ${SRV_FILES})
-
 include_directories(
   ${USE_OROCOS_INCLUDE_DIRS}
   ${catkin_INCLUDE_DIRS}
@@ -105,7 +101,6 @@ target_link_libraries(  rtt_${ROSPACKAGE}_rosservice_proxies ${catkin_LIBRARIES}
 if(DEFINED ${_package}_EXPORTED_TARGETS)
   add_dependencies(       rtt_${ROSPACKAGE}_rosservice_proxies ${${_package}_EXPORTED_TARGETS})
 endif()
-add_file_dependencies(  ${CMAKE_CURRENT_BINARY_DIR}/rtt_rosservice_proxies.cpp "${CMAKE_CURRENT_LIST_FILE}")
 
 get_directory_property(_additional_make_clean_files ADDITIONAL_MAKE_CLEAN_FILES)
 list(APPEND _additional_make_clean_files "${CMAKE_CURRENT_BINARY_DIR}/rtt_rosservice_proxies.cpp")

rtt_roscomm/src/templates/typekit/CMakeLists.txt

@@ -6,8 +6,6 @@ else()
   #add_definitions( -DRTT_COMPONENT )
 endif()
 
-include(AddFileDependencies)
-
 # mqueue transport
 OPTION(ENABLE_MQ "Build posix message queue transport plugin for ${_package}" OFF)
 if(ENABLE_MQ)
@@ -131,7 +129,7 @@ foreach( FILE ${MSG_FILES} )
 
   # Necessary for create_boost_header.py command below
   set(_ROSMSG_GENERATED_BOOST_HEADER  "${rtt_roscomm_GENERATED_HEADERS_OUTPUT_DIRECTORY}/orocos/${ROSMSGBOOSTHEADER}")
-  list(APPEND ROSMSGS_GENERATED_BOOST_HEADERS ${_ROSMSG_GENERATED_BOOST_HEADER})
+  list(APPEND ${_package}_GENERATED_BOOST_HEADERS ${_ROSMSG_GENERATED_BOOST_HEADER})
 
   add_custom_command(
     OUTPUT ${_ROSMSG_GENERATED_BOOST_HEADER}
@@ -140,22 +138,18 @@ foreach( FILE ${MSG_FILES} )
     DEPENDS ${FILE} ${${_package}_EXPORTED_TARGETS} ${CREATE_BOOST_HEADER_EXE_PATH}
     VERBATIM)
 
-  #set_source_files_properties(${ROSMSGS_GENERATED_BOOST_HEADERS} PROPERTIES GENERATED TRUE)
-
   # Message-specific typekit module
   configure_file(
     ros_msg_typekit_plugin.cpp.in
     ${CMAKE_CURRENT_BINARY_DIR}/ros_${ROSMSGNAME}_typekit_plugin.cpp @ONLY )
   list(APPEND rtt-${_package}-typekit_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/ros_${ROSMSGNAME}_typekit_plugin.cpp )
-  add_file_dependencies( ${CMAKE_CURRENT_BINARY_DIR}/ros_${ROSMSGNAME}_typekit.cpp ${FILE})
 
   # Conversion header for CORBA
   if(ENABLE_CORBA)
     configure_file(
       ros_msg_corba_conversion.hpp.in
       ${CMAKE_CURRENT_BINARY_DIR}/ros_${ROSMSGNAME}_corba_conversion.hpp @ONLY )
     list(APPEND rtt-${_package}-ros-transport-corba_SOURCES ${CMAKE_CURRENT_BINARY_DIR}/ros_${ROSMSGNAME}_corba_conversion.hpp )
-    add_file_dependencies( ${CMAKE_CURRENT_BINARY_DIR}/ros_${ROSMSGNAME}_corba_conversion.hpp ${FILE})
   endif()
 
   # Types.hpp helper for extern templates
@@ -208,21 +202,28 @@ include_directories(
 if(NOT DEFINED CMAKE_BUILD_TYPE OR CMAKE_BUILD_TYPE STREQUAL "Release")
   set(CMAKE_BUILD_TYPE MinSizeRel)
 endif()
+add_custom_target(rtt-${_package}-generate_boost_headers
+  DEPENDS ${${_package}_GENERATED_BOOST_HEADERS}
+)
 orocos_typekit(rtt-${_package}-typekit ${rtt-${_package}-typekit_SOURCES})
 target_link_libraries(rtt-${_package}-typekit ${catkin_LIBRARIES} ${${_package}_LIBRARIES} ${USE_OROCOS_LIBRARIES})
+add_dependencies(rtt-${_package}-typekit rtt-${_package}-generate_boost_headers)
 orocos_typekit(rtt-${_package}-ros-transport ${rtt-${_package}-ros-transport_SOURCES})
 target_link_libraries(rtt-${_package}-ros-transport ${catkin_LIBRARIES} ${${_package}_LIBRARIES} ${USE_OROCOS_LIBRARIES})
+add_dependencies(rtt-${_package}-ros-transport rtt-${_package}-generate_boost_headers)
 
 # Build mqueue transport plugin
 if(ENABLE_MQ)
   orocos_typekit(rtt-${_package}-ros-transport-mqueue ${rtt-${_package}-ros-transport-mqueue_SOURCES})
   target_link_libraries(rtt-${_package}-ros-transport-mqueue ${catkin_LIBRARIES} ${${_package}_LIBRARIES} ${USE_OROCOS_LIBRARIES} ${OROCOS-RTT_MQUEUE_LIBRARIES})
+  add_dependencies(rtt-${_package}-ros-transport-mqueue rtt-${_package}-generate_boost_headers)
 endif()
 
 # Build corba transport plugin
 if(ENABLE_CORBA)
   orocos_typekit(rtt-${_package}-ros-transport-corba ${rtt-${_package}-ros-transport-corba_SOURCES})
   target_link_libraries(rtt-${_package}-ros-transport-corba ${catkin_LIBRARIES} ${${_package}_LIBRARIES} ${USE_OROCOS_LIBRARIES} ${OROCOS-RTT_CORBA_LIBRARIES})
+  add_dependencies(rtt-${_package}-ros-transport-corba rtt-${_package}-generate_boost_headers)
 endif()
 
 # Add an explicit dependency between the typekits and message files
@@ -245,26 +246,13 @@ endif()
 #    LIST(APPEND ${PROJECT_NAME}_EXPORTED_TARGETS "rtt-${_package}-ros-transport")  # <-- This is already done in orocos_typekit().
 LIST(APPEND ${PROJECT_NAME}_EXPORTED_INCLUDE_DIRS "${rtt_roscomm_GENERATED_HEADERS_OUTPUT_DIRECTORY}/orocos" ${${_package}_INCLUDE_DIRS})
 
-add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/ros_${_package}_typekit.cpp ${CMAKE_CURRENT_LIST_FILE} ${ROSMSGS_GENERATED_BOOST_HEADERS})
-add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/ros_${_package}_transport.cpp ${CMAKE_CURRENT_LIST_FILE} ${ROSMSGS_GENERATED_BOOST_HEADERS})
-
-if(ENABLE_MQ)
-  add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/ros_${_package}_transport_mqueue.cpp ${CMAKE_CURRENT_LIST_FILE} ${ROSMSGS_GENERATED_BOOST_HEADERS})
-endif()
-
-if(ENABLE_CORBA)
-  add_file_dependencies(${CMAKE_CURRENT_BINARY_DIR}/ros_${_package}_transport_corba.cpp ${CMAKE_CURRENT_LIST_FILE} ${ROSMSGS_GENERATED_BOOST_HEADERS})
-endif()
-
 get_directory_property(_additional_make_clean_files ADDITIONAL_MAKE_CLEAN_FILES)
 list(APPEND _additional_make_clean_files "${rtt-${_package}-typekit_SOURCES};${rtt-${_package}-ros-transport_SOURCES};${rtt-${_package}-ros-transport-corba_SOURCES};${rtt-${_package}-ros-transport-mqueue_SOURCES};${rtt_roscomm_GENERATED_HEADERS_OUTPUT_DIRECTORY}/orocos/${_package}")
 set_directory_properties(PROPERTIES
   ADDITIONAL_MAKE_CLEAN_FILES "${_additional_make_clean_files}")
 
 # Install generated header files (dependent packages might need them)
 if(DEFINED rtt_roscomm_GENERATED_HEADERS_INSTALL_DESTINATION)
-  # install(FILES ${ROSMSGS_GENERATED_BOOST_HEADERS} DESTINATION ${rtt_roscomm_GENERATED_HEADERS_INSTALL_DESTINATION}/${_package}/boost/)
-  # install(DIRECTORY "${rtt_roscomm_GENERATED_HEADERS_OUTPUT_DIRECTORY}/orocos/${_package}/typekit" DESTINATION ${rtt_roscomm_GENERATED_HEADERS_INSTALL_DESTINATION}/orocos/${_package})
   install(
     DIRECTORY "${rtt_roscomm_GENERATED_HEADERS_OUTPUT_DIRECTORY}/orocos/${_package}"
     DESTINATION "${rtt_roscomm_GENERATED_HEADERS_INSTALL_DESTINATION}/orocos")

rtt_tf/CMakeLists.txt

@@ -14,8 +14,8 @@ orocos_install_headers(include/rtt_tf/tf_interface.h)
 
 orocos_generate_package(
   INCLUDE_DIRS include
-  DEPENDS tf
-  DEPENDS_TARGETS rtt_roscomm rtt_geometry_msgs
+  DEPENDS tf tf2
+  DEPENDS_TARGETS rtt_roscomm rtt_geometry_msgs rtt_tf2_msgs
 )
 
 # Tests

rtt_tf/README.md

@@ -1,13 +1,13 @@
 RTT TF
 ======
 
-This package provides an Orocos RTT component for utilizing the TF rigid body
-transform library from within Orocos. This component provides a "tf" service
+This package provides an Orocos RTT component for utilizing the [TF2 rigid body
+transform library](http://wiki.ros.org/tf2) from within Orocos. This component provides a "tf" service
 with operations for requesting and broadcasting sing and batch transforms.
 
 ### Usage
 
-In general, a given process only needs a single TF component. This component
+In general, a given process only needs a single TF2 component. This component
 provides the following operations both on its bare interface and also on the
 provided "tf" RTT service.
 
@@ -47,7 +47,7 @@ connectServices("my_component","tf");
 
 The [rtt\_tf/tf\_interface.h](include/rtt_tf/tf_interface.h) header includes the
 `rtt_tf::TFInterface` class which adds a required service to a given RTT
-component. This can be used for more easily connecting with the TF component.
+component. This can be used for more easily connecting with the TF2 component.
 
 It can be used to create the RTT service requester "tf" like so:
 

rtt_tf/include/rtt_tf/tf_interface.h

@@ -18,13 +18,19 @@ namespace rtt_tf {
       lookupTransformAtTime("lookupTransformAtTime"),
       broadcastTransform("broadcastTransform"),
       broadcastTransforms("broadcastTransforms"),
-      canTransform("canTransform")
+      broadcastStaticTransform("broadcastStaticTransform"),
+      broadcastStaticTransforms("broadcastStaticTransforms"),
+      canTransform("canTransform"),
+      canTransformAtTime("canTransformAtTime")
     {
       owner->requires("tf")->addOperationCaller(lookupTransform);
       owner->requires("tf")->addOperationCaller(lookupTransformAtTime);
       owner->requires("tf")->addOperationCaller(broadcastTransform);
       owner->requires("tf")->addOperationCaller(broadcastTransforms);
+      owner->requires("tf")->addOperationCaller(broadcastStaticTransform);
+      owner->requires("tf")->addOperationCaller(broadcastStaticTransforms);
       owner->requires("tf")->addOperationCaller(canTransform);
+      owner->requires("tf")->addOperationCaller(canTransformAtTime);
     }
 
     //! Check if the operations are ready
@@ -34,14 +40,20 @@ namespace rtt_tf {
         lookupTransformAtTime.ready() &&
         broadcastTransform.ready() &&
         broadcastTransforms.ready() &&
-        canTransform.ready();
+        broadcastStaticTransform.ready() &&
+        broadcastStaticTransforms.ready() &&
+        canTransform.ready() &&
+        canTransformAtTime.ready();
     }
 
     RTT::OperationCaller<geometry_msgs::TransformStamped(const std::string&, const std::string&)> lookupTransform;
     RTT::OperationCaller<geometry_msgs::TransformStamped(const std::string&, const std::string&, const ros::Time&)> lookupTransformAtTime;
     RTT::OperationCaller<void(const geometry_msgs::TransformStamped&)> broadcastTransform;
     RTT::OperationCaller<void(const std::vector<geometry_msgs::TransformStamped>&)> broadcastTransforms;
+    RTT::OperationCaller<void(const geometry_msgs::TransformStamped&)> broadcastStaticTransform;
+    RTT::OperationCaller<void(const std::vector<geometry_msgs::TransformStamped>&)> broadcastStaticTransforms;
     RTT::OperationCaller<bool(const std::string&, const std::string&)> canTransform;
+    RTT::OperationCaller<bool(const std::string&, const std::string&, const ros::Time&)> canTransformAtTime;
   };
 }
 

rtt_tf/package.xml

@@ -16,16 +16,21 @@
 
   <build_depend>rtt</build_depend>
   <build_depend>tf</build_depend>
+  <build_depend>tf2</build_depend>
   <build_depend>rtt_roscomm</build_depend>
   <build_depend>rtt_geometry_msgs</build_depend>
+  <build_depend>rtt_tf2_msgs</build_depend>
 
   <run_depend>rtt</run_depend>
   <run_depend>tf</run_depend>
+  <run_depend>tf2</run_depend>
   <run_depend>rtt_roscomm</run_depend>
   <run_depend>rtt_geometry_msgs</run_depend>
+  <run_depend>rtt_tf2_msgs</run_depend>
 
   <export>
     <rtt_ros>
+      <plugin_depend>rtt_tf2_msgs</plugin_depend>
       <plugin_depend>rtt_roscomm</plugin_depend>
       <plugin_depend>rtt_geometry_msgs</plugin_depend>
     </rtt_ros>