Make message_filters build for ros2 (on windows 10)

utilities/message_filters/CMakeLists.txt

@@ -1,90 +1,36 @@
-cmake_minimum_required(VERSION 2.8.3)
+cmake_minimum_required(VERSION 3.5)
 project(message_filters)
 
 if(NOT WIN32)
   set_directory_properties(PROPERTIES COMPILE_OPTIONS "-Wall;-Wextra")
 endif()
 
-find_package(catkin REQUIRED COMPONENTS roscpp rosconsole)
-catkin_package(
-  INCLUDE_DIRS include
-  LIBRARIES message_filters
-  CATKIN_DEPENDS roscpp rosconsole
-)
-catkin_python_setup()
+find_package(ament_cmake REQUIRED)
+find_package(rclcpp REQUIRED)
 
-find_package(Boost REQUIRED COMPONENTS signals thread)
+set(Boost_USE_STATIC_LIBS ON)
+find_package(Boost REQUIRED)
 
-include_directories(include ${catkin_INCLUDE_DIRS} ${Boost_INCLUDE_DIRS})
-link_directories(${catkin_LIBRARY_DIRS})
+include_directories(include 
+  ${rclcpp_INCLUDE_DIRS} 
+  ${Boost_INCLUDE_DIRS}
+)
 
 add_library(${PROJECT_NAME} src/connection.cpp)
-target_link_libraries(${PROJECT_NAME} ${catkin_LIBRARIES} ${Boost_LIBRARIES})
+target_link_libraries(${PROJECT_NAME} 
+  ${rclcpp_LIBRARIES}
+)
+
+ament_export_include_directories(include)
+ament_export_libraries(${PROJECT_NAME})
+ament_package()
 
 install(TARGETS ${PROJECT_NAME}
-  ARCHIVE DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
-  LIBRARY DESTINATION ${CATKIN_PACKAGE_LIB_DESTINATION}
-  RUNTIME DESTINATION ${CATKIN_GLOBAL_BIN_DESTINATION})
+  ARCHIVE DESTINATION lib
+  LIBRARY DESTINATION lib
+  RUNTIME DESTINATION bin)
 
 install(DIRECTORY include/${PROJECT_NAME}/
-  DESTINATION ${CATKIN_PACKAGE_INCLUDE_DESTINATION}
+  DESTINATION include/${PROJECT_NAME}
   FILES_MATCHING PATTERN "*.h")
 
-if(CATKIN_ENABLE_TESTING)
-  # Ugly workaround for check_test_ran macro issue
-  #add_subdirectory(test)
-  find_package(catkin COMPONENTS rostest rosunit)
-
-  include_directories(${GTEST_INCLUDE_DIRS})
-
-  # ********** Tests **********
-  catkin_add_gtest(${PROJECT_NAME}-msg_cache_unittest test/msg_cache_unittest.cpp)
-  if(TARGET ${PROJECT_NAME}-msg_cache_unittest)
-    target_link_libraries(${PROJECT_NAME}-msg_cache_unittest message_filters ${GTEST_LIBRARIES})
-  endif()
-
-  catkin_add_gtest(${PROJECT_NAME}-time_synchronizer_unittest test/time_synchronizer_unittest.cpp)
-  if(TARGET ${PROJECT_NAME}-time_synchronizer_unittest)
-    target_link_libraries(${PROJECT_NAME}-time_synchronizer_unittest message_filters ${GTEST_LIBRARIES})
-  endif()
-
-  catkin_add_gtest(${PROJECT_NAME}-test_synchronizer test/test_synchronizer.cpp)
-  if(TARGET ${PROJECT_NAME}-test_synchronizer)
-    target_link_libraries(${PROJECT_NAME}-test_synchronizer message_filters ${GTEST_LIBRARIES})
-  endif()
-
-  catkin_add_gtest(${PROJECT_NAME}-test_exact_time_policy test/test_exact_time_policy.cpp)
-  if(TARGET ${PROJECT_NAME}-test_exact_time_policy)
-    target_link_libraries(${PROJECT_NAME}-test_exact_time_policy message_filters ${GTEST_LIBRARIES})
-  endif()
-
-  catkin_add_gtest(${PROJECT_NAME}-test_approximate_time_policy test/test_approximate_time_policy.cpp)
-  if(TARGET ${PROJECT_NAME}-test_approximate_time_policy)
-    target_link_libraries(${PROJECT_NAME}-test_approximate_time_policy message_filters ${GTEST_LIBRARIES})
-  endif()
-
-  catkin_add_gtest(${PROJECT_NAME}-test_simple test/test_simple.cpp)
-  if(TARGET ${PROJECT_NAME}-test_simple)
-    target_link_libraries(${PROJECT_NAME}-test_simple message_filters ${GTEST_LIBRARIES})
-  endif()
-
-  catkin_add_gtest(${PROJECT_NAME}-test_chain test/test_chain.cpp)
-  if(TARGET ${PROJECT_NAME}-test_chain)
-    target_link_libraries(${PROJECT_NAME}-test_chain message_filters ${GTEST_LIBRARIES})
-  endif()
-
-  # Needs to be a rostest because it spins up a node, which blocks until it hears from the master (unfortunately)
-  add_rostest_gtest(${PROJECT_NAME}-time_sequencer_unittest test/time_sequencer_unittest.xml test/time_sequencer_unittest.cpp)
-  if(TARGET ${PROJECT_NAME}-time_sequencer_unittest)
-    target_link_libraries(${PROJECT_NAME}-time_sequencer_unittest message_filters)
-  endif()
-
-  add_rostest_gtest(${PROJECT_NAME}-test_subscriber test/test_subscriber.xml test/test_subscriber.cpp)
-  if(TARGET ${PROJECT_NAME}-test_subscriber)
-    target_link_libraries(${PROJECT_NAME}-test_subscriber message_filters)
-  endif()
-
-  # Unit test of the approximate synchronizer
-  catkin_add_nosetests(test/test_approxsync.py)
-  catkin_add_nosetests(test/test_message_filters_cache.py)
-endif()

utilities/message_filters/include/message_filters/connection.h

@@ -48,8 +48,8 @@ namespace message_filters
 class MESSAGE_FILTERS_DECL Connection
 {
 public:
-  typedef boost::function<void(void)> VoidDisconnectFunction;
-  typedef boost::function<void(const Connection&)> WithConnectionDisconnectFunction;
+  typedef std::function<void(void)> VoidDisconnectFunction;
+  typedef std::function<void(const Connection&)> WithConnectionDisconnectFunction;
   Connection() {}
   Connection(const VoidDisconnectFunction& func);
   Connection(const WithConnectionDisconnectFunction& func, boost::signals2::connection conn);

utilities/message_filters/include/message_filters/macros.h

@@ -25,11 +25,9 @@
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef MESSAGE_FILTERS_MACROS_H_
+#ifndef MESSAGE_FILTERS_MACROS_H_ 
 #define MESSAGE_FILTERS_MACROS_H_
 
-#include <ros/macros.h> // for the DECL's
-
 // Import/export for windows dll's and visibility for gcc shared libraries.
 
 #ifdef ROS_BUILD_SHARED_LIBS // ros is being built around shared libraries

utilities/message_filters/include/message_filters/signal1.h

@@ -1,129 +1,127 @@
 /*********************************************************************
-* Software License Agreement (BSD License)
-*
-*  Copyright (c) 2010, Willow Garage, Inc.
-*  All rights reserved.
-*
-*  Redistribution and use in source and binary forms, with or without
-*  modification, are permitted provided that the following conditions
-*  are met:
-*
-*   * Redistributions of source code must retain the above copyright
-*     notice, this list of conditions and the following disclaimer.
-*   * Redistributions in binary form must reproduce the above
-*     copyright notice, this list of conditions and the following
-*     disclaimer in the documentation and/or other materials provided
-*     with the distribution.
-*   * Neither the name of the Willow Garage nor the names of its
-*     contributors may be used to endorse or promote products derived
-*     from this software without specific prior written permission.
-*
-*  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-*  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-*  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-*  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-*  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-*  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-*  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-*  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-*  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-*  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-*  POSSIBILITY OF SUCH DAMAGE.
-*********************************************************************/
+ * Software License Agreement (BSD License)
+ *
+ *  Copyright (c) 2010, Willow Garage, Inc.
+ *  All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without
+ *  modification, are permitted provided that the following conditions
+ *  are met:
+ *
+ *   * Redistributions of source code must retain the above copyright
+ *     notice, this list of conditions and the following disclaimer.
+ *   * Redistributions in binary form must reproduce the above
+ *     copyright notice, this list of conditions and the following
+ *     disclaimer in the documentation and/or other materials provided
+ *     with the distribution.
+ *   * Neither the name of the Willow Garage nor the names of its
+ *     contributors may be used to endorse or promote products derived
+ *     from this software without specific prior written permission.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ *  FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ *  COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ *  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ *  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *  LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ *  ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *  POSSIBILITY OF SUCH DAMAGE.
+ *********************************************************************/
 
 #ifndef MESSAGE_FILTERS_SIGNAL1_H
 #define MESSAGE_FILTERS_SIGNAL1_H
 
 #include <boost/noncopyable.hpp>
 
 #include "connection.h"
+
 #include <ros/message_event.h>
-#include <ros/parameter_adapter.h>
 
 #include <boost/bind.hpp>
 #include <boost/thread/mutex.hpp>
 
 namespace message_filters
 {
-template<class M>
-class CallbackHelper1
-{
-public:
-  virtual ~CallbackHelper1() {}
-
-  virtual void call(const ros::MessageEvent<M const>& event, bool nonconst_need_copy) = 0;
+  template<class M>
+  class CallbackHelper1
+  {
+  public:
+    virtual ~CallbackHelper1() {}
 
-  typedef boost::shared_ptr<CallbackHelper1<M> > Ptr;
-};
+    virtual void call(const ros::MessageEvent<M const>& event, bool nonconst_need_copy) = 0;
 
-template<typename P, typename M>
-class CallbackHelper1T : public CallbackHelper1<M>
-{
-public:
-  typedef ros::ParameterAdapter<P> Adapter;
-  typedef boost::function<void(typename Adapter::Parameter)> Callback;
-  typedef typename Adapter::Event Event;
+    typedef std::shared_ptr<CallbackHelper1<M> > Ptr;
+  };
 
-  CallbackHelper1T(const Callback& cb)
-  : callback_(cb)
+  template<typename P, typename M>
+  class CallbackHelper1T : public CallbackHelper1<M>
   {
-  }
+  public:
+    typedef std::function<void(const std::shared_ptr<M const>& msg)> Callback;
 
-  virtual void call(const ros::MessageEvent<M const>& event, bool nonconst_force_copy)
-  {
-    Event my_event(event, nonconst_force_copy || event.nonConstWillCopy());
-    callback_(Adapter::getParameter(my_event));
-  }
+    CallbackHelper1T(const Callback& cb)
+      : callback_(cb)
+    {
+    }
 
-private:
-  Callback callback_;
-};
+    virtual void call(const ros::MessageEvent<M const>& event, bool nonconst_force_copy)
+    {
+      // TODO: validate
+      callback_(event.getMessage());
+    }
 
-template<class M>
-class Signal1
-{
-  typedef boost::shared_ptr<CallbackHelper1<M> > CallbackHelper1Ptr;
-  typedef std::vector<CallbackHelper1Ptr> V_CallbackHelper1;
+  private:
+    Callback callback_;
+  };
 
-public:
-  template<typename P>
-  CallbackHelper1Ptr addCallback(const boost::function<void(P)>& callback)
+  template<class M>
+  class Signal1
   {
-    CallbackHelper1T<P, M>* helper = new CallbackHelper1T<P, M>(callback);
+    typedef std::shared_ptr<CallbackHelper1<M> > CallbackHelper1Ptr;
+    typedef std::vector<CallbackHelper1Ptr> V_CallbackHelper1;
+
+  public:
+    template<typename P>
+    CallbackHelper1Ptr addCallback(const std::function<void(P)>& callback)
+    {
+      CallbackHelper1T<P, M>* helper = new CallbackHelper1T<P, M>(callback);
 
-    boost::mutex::scoped_lock lock(mutex_);
-    callbacks_.push_back(CallbackHelper1Ptr(helper));
-    return callbacks_.back();
-  }
+      boost::mutex::scoped_lock lock(mutex_);
+      callbacks_.push_back(CallbackHelper1Ptr(helper));
+      return callbacks_.back();
+    }
 
-  void removeCallback(const CallbackHelper1Ptr& helper)
-  {
-    boost::mutex::scoped_lock lock(mutex_);
-    typename V_CallbackHelper1::iterator it = std::find(callbacks_.begin(), callbacks_.end(), helper);
-    if (it != callbacks_.end())
+    void removeCallback(const CallbackHelper1Ptr& helper)
     {
-      callbacks_.erase(it);
+      boost::mutex::scoped_lock lock(mutex_);
+      typename V_CallbackHelper1::iterator it = std::find(callbacks_.begin(), callbacks_.end(), helper);
+      if (it != callbacks_.end())
+      {
+        callbacks_.erase(it);
+      }
     }
-  }
 
-  void call(const ros::MessageEvent<M const>& event)
-  {
-    boost::mutex::scoped_lock lock(mutex_);
-    bool nonconst_force_copy = callbacks_.size() > 1;
-    typename V_CallbackHelper1::iterator it = callbacks_.begin();
-    typename V_CallbackHelper1::iterator end = callbacks_.end();
-    for (; it != end; ++it)
+    void call(const ros::MessageEvent<M const>& event)
     {
-      const CallbackHelper1Ptr& helper = *it;
-      helper->call(event, nonconst_force_copy);
+      boost::mutex::scoped_lock lock(mutex_);
+      bool nonconst_force_copy = callbacks_.size() > 1;
+      typename V_CallbackHelper1::iterator it = callbacks_.begin();
+      typename V_CallbackHelper1::iterator end = callbacks_.end();
+      for (; it != end; ++it)
+      {
+        const CallbackHelper1Ptr& helper = *it;
+        helper->call(event, nonconst_force_copy);
+      }
     }
-  }
 
-private:
-  boost::mutex mutex_;
-  V_CallbackHelper1 callbacks_;
-};
+  private:
+    boost::mutex mutex_;
+    V_CallbackHelper1 callbacks_;
+  };
 
 } // message_filters