Changeset 126:abc5db1233c8 in finroc_plugins_data_ports

Timestamp:

22.05.2017 01:34:21 (20 months ago)

Author:

Tobias Föhst <foehst@…>

Branch:

17.03

Phase:

public

Rebase:

62653330613263653936313863323438366631643662373766666265396264646361373266326563

Message:

Reimplements tPortPack via std::tuple for proper initialization, typed access and access via integer sequences

Files:

• tPortPack.h (modified) (3 diffs)
• tests/test_collection.cpp (modified) (5 diffs)

tPortPack.h

@@ -40 +40 @@
 // External includes (system with <>, local with "")
 //----------------------------------------------------------------------
+#include "core/tFrameworkElement.h"
+#include "core/log_messages.h"
+#include "rrlib/util/tIteratorRange.h"
+#include "rrlib/util/tIntegerSequence.h"
+
 #include "rrlib/util/tTypeList.h"
-#include "core/tFrameworkElement.h"
 
 //----------------------------------------------------------------------
@@ -63 +67 @@
 //----------------------------------------------------------------------
 //! A group of several ports with different types.
+/*!
+ * This class creates a tuple of instances of the given port template
+ * inserting the given types.  It also provides methods to access the
+ * included ports and their change flags at runtime.
+ *
+ * \param TPort    A port class template to use for every packed port
+ * \param TTypes   A variadic list of the data types used in the ports
+ */
+template <template <typename> class TPort, typename ... TTypes>
+class tPortPack
+{
+  using tPorts = std::tuple<std::unique_ptr<TPort<TTypes>>...>;
+  using tIndex = typename rrlib::util::tIntegerSequenceGenerator<sizeof...(TTypes)>::type;
+
+//----------------------------------------------------------------------
+// Public methods and typedefs
+//----------------------------------------------------------------------
+public:
+
+  /*! Ctor with common port name prefix
+   *
+   * The port names will follow the scheme "<prefix> [0..]"
+   *
+   * \param parent        The parent framework element
+   * \param name_prefix   The common prefix used for all port names
+   */
+  inline tPortPack(core::tFrameworkElement *parent, const std::string &name_prefix)
+  {
+    this->DispatchInitializer(parent, tIndex(), [&name_prefix](size_t i)
+    {
+      return name_prefix + std::to_string(i);
+    });
+  }
+
+  /*! Ctor with custom port names
+   *
+   * The port names are completely taken from two iterators
+   *
+   * \param parent        The parent framework element
+   * \param names_begin   Begin of the list of port names
+   * \param names_end     End of the list of port names
+   */
+  template <typename TIterator>
+  inline tPortPack(core::tFrameworkElement *parent, TIterator names_begin, TIterator names_end)
+  {
+    auto number_of_names = std::distance(names_begin, names_end);
+    if (number_of_names != sizeof...(TTypes))
+    {
+      FINROC_LOG_THROW(rrlib::util::tTraceableException<std::logic_error>("Number of ports names (" + std::to_string(number_of_names) + ") does not fit given number of ports (" + std::to_string(sizeof...(TTypes)) + ")"));
+    }
+    this->DispatchInitializer(parent, tIndex(), [names_begin](size_t i) mutable { return *names_begin++; });
+  }
+
+  /*! Ctor with custom port names (range)
+   *
+   * The port names are completely specified
+   *
+   * \param parent   The parent framework element
+   * \param names    A range of port names to be used
+   */
+  template <typename TIterator>
+  inline tPortPack(core::tFrameworkElement *parent, const rrlib::util::tIteratorRange<TIterator> &names) :
+    tPortPack(parent, names.begin(), names.end())
+  {}
+
+  /*! The number of ports in this port pack
+   *
+   * \returns Number of ports in \a this pack
+   */
+  inline static constexpr size_t NumberOfPorts()
+  {
+    return sizeof...(TTypes);
+  }
+
+  /*! Access a specific port (strong type version, compile time)
+   *
+   * \param Tindex   The index of the port in this pack
+   *
+   * \return The specified port
+   */
+  template <size_t Tindex>
+  inline typename std::tuple_element<Tindex, std::tuple<TPort<TTypes>...>>::type &GetPort()
+  {
+    static_assert(Tindex < this->NumberOfPorts(), "Port index not in range");
+    return *std::get<Tindex>(this->ports);
+  }
+
+  /*! Access a specific port (runtime version)
+   *
+   * \param index   The index of the port in this pack
+   *
+   * \return The specified port
+   */
+  inline core::tPortWrapperBase &GetPort(size_t index)
+  {
+    assert(index < this->NumberOfPorts());
+    return *this->port_wrappers[index];
+  }
+
+  /*! Access a specific port's changed flag
+   *
+   * \param index   The index of the port in this pack
+   *
+   * \return Whether the port has changed or not
+   */
+  inline bool HasChanged(size_t index)
+  {
+    std::vector<bool> changed_flags = this->GetChangedFlags(tIndex()); // TODO: std::vector<bool> may be replaced by auto in c++14 and gcc < 4.9 to avoid heap allocation
+    return changed_flags[index];
+  }
+
+  /*! Check if any port in the pack has changed
+   *
+   * \return Whether any port in the pack has changed
+   */
+  inline bool Changed()
+  {
+    std::vector<bool> changed_flags = this->GetChangedFlags(tIndex()); // TODO: std::vector<bool> may be replaced by auto in c++14 and gcc < 4.9 to avoid heap allocation
+    return std::any_of(changed_flags.begin(), changed_flags.end(), [](bool x)
+    {
+      return x;
+    });
+  }
+
+  /*! Publish a tuple of value through this port pack (only for output ports)
+   *
+   * \param values      A tuple of values that can be published via this portspacks ports
+   * \param timestamp   An optional timestamp to use (default: cNO_TIME)
+   */
+  template <typename ... TValues>
+  inline void Publish(const std::tuple<TValues...> &values, const rrlib::time::tTimestamp timestamp = rrlib::time::cNO_TIME)
+  {
+    this->DispatchPublisher(tIndex(), values, timestamp);
+  }
+
+  /*! Deletion of the port pack's ports
+   */
+  inline void ManagedDelete()
+  {
+    this->ManagedDelete(tIndex());
+  }
+
+//----------------------------------------------------------------------
+// Protected methods
+//----------------------------------------------------------------------
+protected:
+
+  /*! Ctor with common port name prefix and port number offset to support legacy code
+   *
+   * The port names will follow the scheme "<prefix> [<offset>..]"
+   *
+   * \param parent        The parent framework element
+   * \param name_prefix   The common prefix used for all port names
+   * \param offset        Offset for numbering the created ports
+   */
+  inline tPortPack(core::tFrameworkElement *parent, const std::string &name_prefix, size_t offset)
+  {
+    this->DispatchInitializer(parent, tIndex(), [&name_prefix, offset](size_t i)
+    {
+      return name_prefix + std::to_string(i + offset);
+    });
+  }
+
+//----------------------------------------------------------------------
+// Private fields and methods
+//----------------------------------------------------------------------
+private:
+
+  tPorts ports;
+  core::tPortWrapperBase *port_wrappers[sizeof...(TTypes)];
+
+  template <size_t Tindex>
+  int InitializePort(core::tFrameworkElement *parent, const std::string &name)
+  {
+    std::get<Tindex>(this->ports).reset(new typename std::tuple_element<Tindex, std::tuple<TPort<TTypes>...>>::type(name, parent));
+    std::get<Tindex>(this->ports)->Init();
+    return 0;
+  }
+
+  template <int ... Tindex, typename TNameGenerator>
+  void DispatchInitializer(core::tFrameworkElement *parent, rrlib::util::tIntegerSequence<Tindex...>, TNameGenerator name_generator)
+  {
+    __attribute__((unused)) int foo[] = { InitializePort<Tindex>(parent, name_generator(Tindex))... };
+    auto port_wrappers = std::initializer_list<core::tPortWrapperBase *> {std::get<Tindex>(this->ports).get()...};
+    std::copy(port_wrappers.begin(), port_wrappers.end(), this->port_wrappers);
+  }
+
+  template <typename T, typename TValue>
+  int PublishPort(T &port, const TValue &value, const rrlib::time::tTimestamp &timestamp)
+  {
+    port.Publish(value, timestamp);
+    return 0;
+  }
+  template <int ... Tindex, typename ... TValues>
+  void DispatchPublisher(rrlib::util::tIntegerSequence<Tindex...>, const std::tuple<TValues...> &values, const rrlib::time::tTimestamp timestamp)
+  {
+    __attribute__((unused)) int foo[] = { PublishPort(*std::get<Tindex>(this->ports), std::get<Tindex>(values), timestamp)... };
+  }
+
+  template <int ... Tindex>
+  inline std::initializer_list<bool> GetChangedFlags(rrlib::util::tIntegerSequence<Tindex...>)
+  {
+    return { std::get<Tindex>(this->ports)->HasChanged()..., false };
+  }
+
+  template <int ... Tindex>
+  inline void ManagedDelete(rrlib::util::tIntegerSequence<Tindex...>)
+  {
+    for (auto p : this->port_wrappers)
+    {
+      p->GetWrapped()->ManagedDelete();
+    }
+  }
+
+};
+
 /*!
  * This class creates a list of instances of the given port template
@@ -69 +289 @@
  * port on a specific layer at runtime.
  *
+ * \note This class exists to support legacy code that used the initial
+ *       version with tTypeList and 1-based port numbers.
+ *
  * \param TPort       A port class template to use for every packed port
  * \param TTypeList   A list of the data types used in the ports. e.g. rrlib::util::tTypeList
- * \param Tsize       The pack creates ports using TTypeList[0] to TTypeList[Tsize - 1]. This parameter must not be greater than TTypeList::cSIZE - 1 and is typically inferred and not set by the user.
  */
-template <template <typename> class TPort, typename TTypeList, size_t Tsize = rrlib::util::type_list::tSizeOf<TTypeList>::cVALUE>
-class tPortPack : private tPortPack < TPort, TTypeList, Tsize - 1 >
+template <template <typename> class TPort, typename ... TTypes>
+class tPortPack<TPort, rrlib::util::tTypeList<TTypes...>> : public tPortPack<TPort, TTypes...>
 {
-
-  template <bool value, typename>
-  using CheckIterators = std::integral_constant<bool, value>;
-
-//----------------------------------------------------------------------
-// Public methods and typedefs
-//----------------------------------------------------------------------
 public:
-
+  using tPortPack<TPort, TTypes...>::tPortPack;
   inline tPortPack(core::tFrameworkElement *parent, const std::string &name_prefix) :
-    tPortPack < TPort, TTypeList, Tsize - 1 > (parent, name_prefix),
-    port(name_prefix + std::to_string(Tsize), parent)
-  {
-    this->port.Init();
-  }
-
-  template <typename TIterator, typename std::enable_if<CheckIterators<(Tsize> 1), TIterator>::value, int>::type = 0 >
-      inline tPortPack(core::tFrameworkElement *parent, TIterator names_begin, TIterator names_end) :
-        tPortPack < TPort, TTypeList, Tsize - 1 > (parent, names_begin, names_end - 1),
-        port(*(names_end - 1), parent)
-  {
-    this->port.Init();
-  }
-
-  template <typename TIterator, typename std::enable_if<CheckIterators<(Tsize == 1), TIterator>::value, int>::type = 0>
-  inline tPortPack(core::tFrameworkElement *parent, TIterator names_begin, TIterator names_end) :
-    tPortPack < TPort, TTypeList, Tsize - 1 > (parent, *names_begin),
-    port(*names_begin, parent)
-  {
-    this->port.Init();
-  }
-
-  inline size_t NumberOfPorts() const
-  {
-    return Tsize;
-  }
-
-  inline core::tPortWrapperBase &GetPort(size_t index)
-  {
-    assert(index < this->NumberOfPorts());
-    if (index == Tsize - 1)
-    {
-      return this->port;
-    }
-    return tPortPack < TPort, TTypeList, Tsize - 1 >::GetPort(index);
-  }
-
-  inline bool HasChanged(size_t index)
-  {
-    assert(index < this->NumberOfPorts());
-    if (index == Tsize - 1)
-    {
-      return this->port.HasChanged();
-    }
-    return tPortPack < TPort, TTypeList, Tsize - 1 >::HasChanged(index);
-  }
-
-  inline void ManagedDelete()
-  {
-    this->port.GetWrapped()->ManagedDelete();
-    tPortPack < TPort, TTypeList, Tsize - 1 >::ManagedDelete();
-  }
-
-//----------------------------------------------------------------------
-// Private fields and methods
-//----------------------------------------------------------------------
-
-private:
-
-  TPort < typename TTypeList::template tAt < Tsize - 1 >::tResult > port;
-
-};
-
-//! The partial specialization of tPortPack to terminate recursion
-template <template <typename> class TPort, typename TTypeList>
-struct tPortPack <TPort, TTypeList, 0>
-{
-  inline tPortPack(core::tFrameworkElement *parent, const std::string &name_prefix)
-  {}
-
-  template <typename TIterator>
-  inline tPortPack(core::tFrameworkElement *parent, TIterator names_begin, TIterator names_end)
-  {}
-
-  inline core::tPortWrapperBase &GetPort(size_t index)
-  {
-    return *reinterpret_cast<core::tPortWrapperBase *>(0);
-  };
-
-  inline bool HasChanged(size_t index)
-  {
-    return false;
-  };
-
-  inline void ManagedDelete()
+    tPortPack<TPort, TTypes...>(parent, name_prefix, 1)
   {}
 };

tests/test_collection.cpp

@@ -45 +45 @@
 #include "plugins/data_ports/tThreadLocalBufferManagement.h"
 #include "plugins/data_ports/tPortPack.h"
+
+#include "plugins/structure/tModule.h"
 
 //----------------------------------------------------------------------
@@ -369 +371 @@
 }
 
+struct mTestModule : structure::tModule
+{
+  using tModule::tModule;
+  void Update() override {}
+};
+
+template <typename ... T, typename NAMES>
+void PortPackTestHelper(core::tFrameworkElement *parent, const std::initializer_list<NAMES> &names_initializer)
+{
+  data_ports::tPortPack<mTestModule::tInput, T...> ports(parent, "X");
+
+  RRLIB_UNIT_TESTS_EQUALITY(sizeof...(T), ports.NumberOfPorts());
+  for (size_t i = 0; i < sizeof...(T); ++i)
+  {
+    RRLIB_UNIT_TESTS_EQUALITY("X" + std::to_string(i), ports.GetPort(i).GetName());
+  }
+
+  std::array<NAMES, sizeof...(T)> names;
+  assert(names_initializer.size() == names.size());
+  std::copy(names_initializer.begin(), names_initializer.end(), names.begin());
+  data_ports::tPortPack<tInputPort, T...> named_ports(parent, names.begin(), names.end());
+
+  RRLIB_UNIT_TESTS_EQUALITY(sizeof...(T), named_ports.NumberOfPorts());
+  for (size_t i = 0; i < sizeof...(T); ++i)
+  {
+    RRLIB_UNIT_TESTS_EQUALITY(std::string(names[i]), named_ports.GetPort(i).GetName());
+  }
+}
+
 class DataPortsTestCollection : public rrlib::util::tUnitTestSuite
 {
@@ -374 +405 @@
   RRLIB_UNIT_TESTS_ADD_TEST(Test);
   RRLIB_UNIT_TESTS_ADD_TEST(PortPack);
+  RRLIB_UNIT_TESTS_ADD_TEST(PortPackLegacy);
   RRLIB_UNIT_TESTS_END_SUITE;
 
@@ -403 +435 @@
   void PortPack()
   {
-    auto parent = new core::tFrameworkElement(&core::tRuntimeEnvironment::GetInstance(), "TestPortPack");
+    auto parent = new mTestModule(&core::tRuntimeEnvironment::GetInstance(), "TestModule");
+
+    PortPackTestHelper<int, double, std::string, bool>(parent, {"foo", "bar", "baz", "fnord"});
+
+    std::array<std::string, 0> empty_names;
+    RRLIB_UNIT_TESTS_EQUALITY(size_t(0), data_ports::tPortPack<mTestModule::tInput>(parent, "X").NumberOfPorts());
+    RRLIB_UNIT_TESTS_EQUALITY(size_t(0), data_ports::tPortPack<mTestModule::tInput>(parent, empty_names.begin(), empty_names.end()).NumberOfPorts());
+  }
+
+  void PortPackLegacy()
+  {
+    auto parent = new mTestModule(&core::tRuntimeEnvironment::GetInstance(), "TestModule");
 
     using tTypeList = rrlib::util::tTypeList<int, double, std::string, bool>;
-    data_ports::tPortPack<tInputPort, tTypeList> ports(parent, "X");
+    data_ports::tPortPack<mTestModule::tInput, tTypeList> ports(parent, "X");
 
     RRLIB_UNIT_TESTS_EQUALITY(tTypeList::cSIZE, ports.NumberOfPorts());
@@ -416 +459 @@
 
     std::array<std::string, tTypeList::cSIZE> names {"foo", "bar", "baz", "fnord"};
-    data_ports::tPortPack<tInputPort, tTypeList> named_ports(parent, names.begin(), names.end());
+    data_ports::tPortPack<mTestModule::tInput, tTypeList> named_ports(parent, names.begin(), names.end());
 
     for (size_t i = 0; i < tTypeList::cSIZE; ++i)