AbstractRefAccessor.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// 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.
 
 
#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:
  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());
  }
 
  bool isLoaded(int src) const
  {
    return mSizeOfs[src] != 0;
  }
 
  template <typename U>
  const U& get_as(int src, int idx) const
  {
    return *reinterpret_cast<const U*>(getPtr(src, idx));
  }
 
  template <typename U, typename I>
  const U& get_as(const I globIdx) const
  {
    return get_as<U>(globIdx.getSource(), globIdx.getIndex());
  }
 
  const T& get(int src, int idx) const
  {
    return get_as<T>(src, idx);
  }
 
  template <typename I>
  const T& get(const I globIdx) const
  {
    return get_as<T>(globIdx.getSource(), globIdx.getIndex());
  }
 
  template <typename U>
  auto getSpan(int src) const
  {
    return getSize(src) ? gsl::span<const U>(reinterpret_cast<const U*>(getPtr(src, 0)), getSize(src)) : gsl::span<const U>();
  }
 
  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