Aggregated container + access with global index

Allows to absorb the containers of objects usually derived from the common base class and
to access them with global index (e.g. like AbstractRef)

Author: shahor02

DataFormats/common/CMakeLists.txt

@@ -13,6 +13,7 @@ o2_add_library(CommonDataFormat
                        src/BunchFilling.cxx
                        src/FlatHisto1D.cxx
                        src/FlatHisto2D.cxx
+                       src/AbstractRefAccessor.cxx
                PUBLIC_LINK_LIBRARIES O2::CommonConstants O2::GPUCommon
                                      ROOT::Core FairRoot::Base ms_gsl::ms_gsl)
 
@@ -40,3 +41,8 @@ o2_add_test(FlatHisto
             SOURCES test/testFlatHisto.cxx
             COMPONENT_NAME CommonDataFormat
             PUBLIC_LINK_LIBRARIES O2::CommonDataFormat)
+
+o2_add_test(AbstractRefAccessor
+            SOURCES test/testAbstractRefAccessor.cxx
+            COMPONENT_NAME CommonDataFormat
+            PUBLIC_LINK_LIBRARIES O2::CommonDataFormat)

DataFormats/common/include/CommonDataFormat/AbstractRefAccessor.h

@@ -0,0 +1,95 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file AbstractRefAccessor.h
+/// \brief Accessor for objects of the same base class located in different containers
+/// \author ruben.shahoyan@cern.ch
+
+#ifndef O2_POLYACCESSOR_H
+#define O2_POLYACCESSOR_H
+
+#include <array>
+#include <gsl/span>
+
+namespace o2
+{
+namespace dataformats
+{
+
+/*
+  AbstractRefAccessor allows to register multiple containers of objects convertible to type T and 
+  to access them by providing a global index indicating the registered source ID and the
+  index within the original container
+*/
+
+template <typename T, int N>
+class AbstractRefAccessor
+{
+ public:
+  /// register container in the accessor
+  template <typename C>
+  void registerContainer(const C& cont, int src)
+  {
+    mSizeOfs[src] = sizeof(typename std::remove_reference<decltype(cont)>::type::value_type);
+    mSizes[src] = cont.size();
+    mContainerPtr[src] = reinterpret_cast<const char*>(cont.data());
+  }
+
+  /// get object as user provided type from explicitly provided source, index
+  template <typename U>
+  const U& get_as(int src, int idx) const
+  {
+    return *reinterpret_cast<const U*>(getPtr(src, idx));
+  }
+
+  /// get object as user provided type from explicitly provided source, index
+  template <typename U, typename I>
+  const U& get_as(const I globIdx) const
+  {
+    return get_as<U>(globIdx.getSource(), globIdx.getIndex());
+  }
+
+  /// get object from explicitly provided source, index
+  const T& get(int src, int idx) const
+  {
+    return get_as<T>(src, idx);
+  }
+
+  /// get object from the global index
+  template <typename I>
+  const T& get(const I globIdx) const
+  {
+    return get_as<T>(globIdx.getSource(), globIdx.getIndex());
+  }
+
+  /// access particula source container as a span
+  template <typename U>
+  auto getSpan(int src) const
+  {
+    return gsl::span<const U>(reinterpret_cast<const U*>(getPtr(src, 0), getSize(src)));
+  }
+
+  size_t getSize(int src) const
+  {
+    return mSizes[src];
+  }
+
+ private:
+  auto getPtr(int src, int idx) const { return mContainerPtr[src] + mSizeOfs[src] * idx; }
+
+  std::array<size_t, N> mSizeOfs{};           // sizeof for all containers elements
+  std::array<size_t, N> mSizes{};             // size of eack container
+  std::array<const char*, N> mContainerPtr{}; // pointers on attached containers
+};
+
+} // namespace dataformats
+} // namespace o2
+
+#endif

DataFormats/common/src/AbstractRefAccessor.cxx

@@ -0,0 +1,15 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+/// \file AbstractRefAccessor.h
+/// \brief Accessor for objects of the same base class located in different containers
+/// \author ruben.shahoyan@cern.ch
+
+#include "CommonDataFormat/AbstractRefAccessor.h"

DataFormats/common/src/CommonDataFormatLinkDef.h

@@ -42,12 +42,12 @@
 
 #pragma link C++ class std::vector < o2::dataformats::RangeReference < int, int>> + ;
 
+#pragma link C++ class o2::dataformats::AbstractRef < 25, 4, 3> + ;
+
 #pragma link C++ class o2::InteractionRecord + ;
 #pragma link C++ class o2::InteractionTimeRecord + ;
 #pragma link C++ class o2::BunchFilling + ;
 
-#pragma link C++ class o2::dataformats::AbstractRef < 26, 3, 3> + ;
-
 #pragma link C++ class o2::dataformats::FlatHisto1D < float> + ;
 #pragma link C++ class o2::dataformats::FlatHisto1D < double> + ;
 #pragma link C++ class o2::dataformats::FlatHisto1D_f + ;

DataFormats/common/test/testAbstractRefAccessor.cxx

@@ -0,0 +1,96 @@
+// Copyright CERN and copyright holders of ALICE O2. This software is
+// distributed under the terms of the GNU General Public License v3 (GPL
+// Version 3), copied verbatim in the file "COPYING".
+//
+// See http://alice-o2.web.cern.ch/license for full licensing information.
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#define BOOST_TEST_MODULE Test AbstractRefAccessor class
+#define BOOST_TEST_MAIN
+#define BOOST_TEST_DYN_LINK
+#include <numeric>
+#include <boost/test/unit_test.hpp>
+#include "CommonDataFormat/AbstractRefAccessor.h"
+#include "CommonDataFormat/AbstractRef.h"
+#include "Framework/Logger.h"
+
+using namespace o2::dataformats;
+
+struct Base {
+  int b = 0;
+};
+
+struct Foo1 : public Base {
+  int f1 = 0;
+};
+
+struct Foo2 : public Foo1 {
+  int f2 = 0;
+};
+
+struct Bar1 : public Base {
+  double b1 = 0.;
+};
+
+struct GloIdx : public AbstractRef<25, 4, 3> {
+  enum Source : uint8_t { // provenance of the
+    ID0,
+    ID1,
+    ID2,
+    ID3,
+    NSources
+  };
+  using AbstractRef<25, 4, 3>::AbstractRef;
+};
+
+// basic AbstractRefAccessor
+BOOST_AUTO_TEST_CASE(AbstractRefAccess)
+{
+
+  std::vector<Base> vb(10);
+  std::vector<Foo1> vf(10);
+  std::array<Foo2, 10> af;
+  std::vector<Bar1> bar(10);
+
+  std::vector<GloIdx> vid;
+
+  for (int i = 0; i < 10; i++) {
+    vb[i].b = GloIdx::ID0 * 100 + i;
+    vid.emplace_back(i, GloIdx::ID1);
+
+    vf[i].b = GloIdx::ID1 * 100 + i;
+    vf[i].f1 = 0.5 + 100 + i;
+    vid.emplace_back(i, GloIdx::ID2);
+
+    af[i].b = GloIdx::ID2 * 100 + i;
+    af[i].f2 = 0.8 + 100 + i;
+    vid.emplace_back(i, GloIdx::ID3);
+
+    bar[i].b = GloIdx::ID3 * 100 + i;
+    bar[i].b1 = 0.2 + 300 + i;
+    vid.emplace_back(i, GloIdx::ID3);
+  }
+
+  AbstractRefAccessor<Base, GloIdx::NSources> acc;
+
+  acc.registerContainer(vb, GloIdx::ID0);
+  acc.registerContainer(vf, GloIdx::ID1);
+  acc.registerContainer(af, GloIdx::ID2);
+  acc.registerContainer(bar, GloIdx::ID3);
+
+  size_t nid = vid.size();
+  for (size_t i = 0; i < nid; i++) {
+    auto gid = vid[i];
+    const auto& obj = acc.get(gid);
+    int expect = gid.getSource() * 100 + i / GloIdx::NSources;
+    LOG(INFO) << i << " ? " << obj.b << " == " << expect << " for " << gid;
+    BOOST_CHECK(obj.b == expect);
+  }
+
+  const auto& barEl = acc.get_as<Bar1>(vid.back());
+  LOG(INFO) << " ? " << barEl.b1 << " == " << bar.back().b1;
+  BOOST_CHECK(barEl.b1 == bar.back().b1);
+}