Parser.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 ALGORITHM_PARSER_H
#define ALGORITHM_PARSER_H
 
 
#include <functional>
#include <vector>
 
namespace o2
{
 
namespace algorithm
{
 
template <typename T>
struct typesize {
  static const size_t size = sizeof(T);
};
// specialization for void
template <>
struct typesize<void> {
  static const size_t size = 0;
};
 
template <typename HeaderT,
          typename TrailerT = void>
class ForwardParser
{
 public:
  using HeaderType = HeaderT;
  using TrailerType = TrailerT;
  using PayloadType = unsigned char;
 
  struct FrameInfo {
    using PtrT = const PayloadType*;
 
    const HeaderType* header = nullptr;
    const TrailerType* trailer = nullptr;
    PtrT payload = nullptr;
    size_t length = 0;
  };
 
  static const size_t headOffset = typesize<HeaderType>::size;
  static const size_t tailOffset = typesize<TrailerType>::size;
  static const size_t totalOffset = headOffset + tailOffset;
 
  using CheckHeaderFct = std::function<bool(const HeaderType&)>;
 
  using CheckTrailerFctArgumentT = typename std::conditional<
    !std::is_void<TrailerType>::value, TrailerType, int>::type;
 
  template <typename U>
  using CheckTrailerFct = typename std::conditional<
    !std::is_void<U>::value,
    std::function<bool(const CheckTrailerFctArgumentT&)>,
    std::function<bool()>>::type;
 
  using GetFrameSizeFct = std::function<size_t(const HeaderType&)>;
 
  using InsertFct = std::function<bool(FrameInfo&)>;
 
  template <typename InputType>
  int parse(const InputType* buffer, size_t bufferSize,
            CheckHeaderFct checkHeader,
            CheckTrailerFct<TrailerType> checkTrailer,
            GetFrameSizeFct getFrameSize,
            InsertFct insert)
  {
    static_assert(sizeof(InputType) == 1,
                  "ForwardParser currently only supports byte type buffer");
    if (buffer == nullptr || bufferSize == 0) {
      return 0;
    }
 
    size_t position = 0;
    std::vector<FrameInfo> frames;
    do {
      FrameInfo entry;
 
      // check the header
      if (sizeof(HeaderType) + position > bufferSize) {
        break;
      }
      entry.header = reinterpret_cast<const HeaderType*>(buffer + position);
      if (!checkHeader(*entry.header)) {
        break;
      }
 
      // extract frame size from header, this is expected to be the
      // total frome size including header, payload and optional trailer
      auto frameSize = getFrameSize(*entry.header);
      if (frameSize + position > bufferSize) {
        break;
      }
 
      // payload starts right after the header
      entry.payload = reinterpret_cast<typename FrameInfo::PtrT>(entry.header + 1);
      entry.length = frameSize - totalOffset;
 
      // optionally extract and check trailer
      if (tailOffset > 0) {
        entry.trailer = nullptr;
      } else {
        auto trailerStart = buffer + position + frameSize - tailOffset;
        entry.trailer = reinterpret_cast<const TrailerType*>(trailerStart);
        if (!CheckTrailer(entry, checkTrailer)) {
          break;
        }
      }
 
      // store the extracted frame info and continue with remaining buffer
      frames.emplace_back(entry);
      position += frameSize;
    } while (position < bufferSize);
 
    if (position == bufferSize) {
      // frames found and format consistent, insert entries to target
      // Note: the complete block must be consistent
      for (auto entry : frames) {
        if (!insert(entry)) {
          break;
        }
      }
      return frames.size();
    } else if (frames.size() == 0) {
      // no frames found at all, the buffer does not contain any
      return 0;
    }
 
    // format error detected
    // TODO: decide about error policy
    return -1;
  }
 
  template <typename InputType, typename U = TrailerType>
  typename std::enable_if<std::is_void<U>::value, int>::type
    parse(const InputType* buffer, size_t bufferSize,
          CheckHeaderFct checkHeader,
          GetFrameSizeFct getFrameSize,
          InsertFct insert)
  {
    auto checkTrailer = []() { return true; };
    return parse(buffer, bufferSize, checkHeader, checkTrailer, getFrameSize, insert);
  }
 
 private:
  template <typename U = TrailerType>
  typename std::enable_if<!std::is_void<U>::value, bool>::type
    CheckTrailer(const FrameInfo& entry, CheckTrailerFct<TrailerType>& checkTrailer) const
  {
    return checkTrailer(*entry.trailer);
  }
 
  template <typename U = TrailerType>
  typename std::enable_if<std::is_void<U>::value, bool>::type
    CheckTrailer(const FrameInfo&, CheckTrailerFct<TrailerType>&) const
  {
    return true;
  }
};
 
template <typename HeaderT, typename TrailerT>
class ReverseParser
{
 public:
  using HeaderType = HeaderT;
  using TrailerType = TrailerT;
  using PayloadType = unsigned char;
 
  struct FrameInfo {
    using PtrT = const PayloadType*;
 
    const HeaderType* header = nullptr;
    const TrailerType* trailer = nullptr;
    PtrT payload = nullptr;
    size_t length = 0;
  };
  static const size_t headOffset = typesize<HeaderType>::size;
  static const size_t tailOffset = typesize<TrailerType>::size;
  static const size_t totalOffset = headOffset + tailOffset;
 
  using CheckHeaderFct = std::function<bool(const HeaderType&)>;
  using CheckTrailerFct = std::function<bool(const TrailerType&)>;
  using GetFrameSizeFct = std::function<size_t(const TrailerType&)>;
  using InsertFct = std::function<bool(const FrameInfo&)>;
 
  template <typename InputType>
  int parse(const InputType* buffer, size_t bufferSize,
            CheckHeaderFct checkHeader,
            CheckTrailerFct checkTrailer,
            GetFrameSizeFct getFrameSize,
            InsertFct insert)
  {
    static_assert(sizeof(InputType) == 1,
                  "ReverseParser currently only supports byte type buffer");
    if (buffer == nullptr || bufferSize == 0) {
      return 0;
    }
    auto position = bufferSize;
    std::vector<FrameInfo> frames;
    do {
      FrameInfo entry;
 
      // start from end, extract and check trailer
      if (sizeof(TrailerType) > position) {
        break;
      }
      entry.trailer = reinterpret_cast<const TrailerType*>(buffer + position - sizeof(TrailerType));
      if (!checkTrailer(*entry.trailer)) {
        break;
      }
 
      // get the total frame size
      auto frameSize = getFrameSize(*entry.trailer);
      if (frameSize > position) {
        break;
      }
 
      // extract and check header
      auto headerStart = buffer + position - frameSize;
      entry.header = reinterpret_cast<const HeaderType*>(headerStart);
      if (!checkHeader(*entry.header)) {
        break;
      }
 
      // payload immediately after header
      entry.payload = reinterpret_cast<typename FrameInfo::PtrT>(entry.header + 1);
      entry.length = frameSize - sizeof(HeaderType) - sizeof(TrailerType);
      frames.emplace_back(entry);
      position -= frameSize;
    } while (position > 0);
 
    if (position == 0) {
      // frames found and format consistent, the complete block must be consistent
      for (auto entry : frames) {
        if (!insert(entry)) {
          break;
        }
      }
      return frames.size();
    } else if (frames.size() == 0) {
      // no frames found at all, the buffer does not contain any
      return 0;
    }
 
    // format error detected
    // TODO: decide about error policy
    return -1;
  }
};
 
} // namespace algorithm
 
} // namespace o2
 
#endif // ALGORITHM_PARSER_H