StaticSequenceAllocator.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.
 
 
namespace o2
{
namespace algorithm
{
 
template <typename HeaderT, typename TrailerT = void>
struct Composite {
  using HeaderType = HeaderT;
  using TrailerType = TrailerT;
  size_t compositeLength = 0;
  size_t trailerLength = 0;
  size_t dataLength = 0;
 
  template <size_t N,
            typename U = TrailerType>
  constexpr Composite(const HeaderType h, const char (&d)[N],
                      typename std::conditional<!std::is_void<U>::value, const TrailerType, int>::type t,
                      typename std::enable_if<!std::is_void<U>::value>::type* = nullptr)
    : header(h), data(d), trailer(t)
  {
    dataLength = N;
    trailerLength = sizeof(TrailerType);
    compositeLength = sizeof(HeaderType) + dataLength + trailerLength;
  }
 
  template <size_t N,
            typename U = TrailerType>
  constexpr Composite(const HeaderType& h, const char (&d)[N],
                      typename std::enable_if<std::is_void<U>::value>::type* = nullptr)
    : header(h), data(d)
  {
    dataLength = N;
    trailerLength = 0;
    compositeLength = sizeof(HeaderType) + dataLength + trailerLength;
  }
 
  constexpr size_t getLength() const noexcept
  {
    return compositeLength;
  }
 
  constexpr size_t getDataLength() const noexcept
  {
    return dataLength;
  }
 
  template <typename BufferT>
  constexpr size_t insert(BufferT* buffer) const noexcept
  {
    static_assert(sizeof(BufferT) == 1, "buffer required to be of byte-type");
    size_t length = 0;
    memcpy(buffer + length, &header, sizeof(HeaderType));
    length += sizeof(HeaderType);
    memcpy(buffer + length, data, dataLength);
    length += dataLength;
    if (trailerLength > 0) {
      memcpy(buffer + length, &trailer, trailerLength);
      length += trailerLength;
    }
    return length;
  }
 
  const HeaderType header;
  const char* data = nullptr;
  typename std::conditional<!std::is_void<TrailerType>::value, const TrailerType, int>::type trailer;
};
 
// variable list
template <typename T, typename... TArgs>
constexpr size_t sequenceLength(const T& first, const TArgs... args) noexcept
{
  return sequenceLength(first) + sequenceLength(args...);
}
 
template <typename T>
constexpr size_t sequenceLength(const T& first) noexcept
{
  return first.getLength();
}
 
template <typename BufferT, typename T, typename... TArgs>
constexpr size_t sequenceInsert(BufferT* buffer, const T& first, const TArgs... args) noexcept
{
  static_assert(sizeof(BufferT) == 1, "buffer required to be of byte-type");
  auto length = sequenceInsert(buffer, first);
  length += sequenceInsert(buffer + length, args...);
  return length;
}
 
template <typename BufferT, typename T>
constexpr size_t sequenceInsert(BufferT* buffer, const T& element) noexcept
{
  // TODO: make a general algorithm, at the moment this serves the
  // Composite class as a special case
  return element.insert(buffer);
}
 
struct StaticSequenceAllocator {
  using value_type = unsigned char;
  using BufferType = std::unique_ptr<value_type[]>;
 
  BufferType buffer;
  size_t bufferSize;
 
  size_t size() const { return bufferSize; }
 
  StaticSequenceAllocator() = delete;
 
  template <typename... Targs>
  StaticSequenceAllocator(Targs... args)
  {
    bufferSize = sequenceLength(args...);
    buffer = std::make_unique<value_type[]>(bufferSize);
    sequenceInsert(buffer.get(), args...);
  }
};
 
} // namespace algorithm
} // namespace o2