TableView.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_TABLEVIEW_H
#define ALGORITHM_TABLEVIEW_H
 
 
#include <vector>
#include <map>
 
namespace o2
{
 
namespace algorithm
{
 
template <typename RowDescT,    // row description
          typename ColumnDescT, // column description
          typename ParserT      // parser type (forward/backward)
          >
class TableView
{
 public:
  TableView() = default;
  ~TableView() = default;
 
  using RowDescType = RowDescT;
  using ColumnIndexType = ColumnDescT;
  using ParserType = ParserT;
 
  struct FrameIndex {
    ColumnIndexType columnIndex;
    unsigned row;
 
    bool operator<(const FrameIndex& rh) const
    {
      if (rh.columnIndex < columnIndex) {
        return false;
      }
      if (columnIndex < rh.columnIndex) {
        return true;
      }
      return row < rh.row;
    }
  };
 
  struct FrameData {
    const std::byte* buffer = nullptr;
    size_t size = 0;
  };
 
  size_t addRow(RowDescType rowData, std::byte* seqData, size_t seqSize)
  {
    unsigned nFrames = mFrames.size();
    unsigned currentRow = mRowData.size();
    ParserType p;
    p.parse(
      seqData, seqSize,
      [](const typename ParserT::HeaderType& h) { return (h); },
      [](const typename ParserT::TrailerType& t) { return (t); },
      [](const typename ParserT::TrailerType& t) {
        return t.dataLength + ParserT::totalOffset;
      },
      [this, currentRow](typename ParserT::FrameInfo entry) {
        // insert the header as column index in ascending order
        auto position = mColumns.begin();
        while (position != mColumns.end() && *position < *entry.header) {
          position++;
        }
        if (position == mColumns.end() || *entry.header < *position) {
          mColumns.emplace(position, *entry.header);
        }
 
        // insert frame descriptor under key composed from header and row
        auto result = mFrames.emplace(FrameIndex{*entry.header, currentRow},
                                      FrameData{(std::byte*)entry.payload, entry.length});
        return result.second;
      });
    auto insertedFrames = mFrames.size() - nFrames;
    if (insertedFrames > 0) {
      mRowData.emplace_back(rowData);
    }
    return insertedFrames;
  }
 
  void clear()
  {
    mFrames.clear();
    mColumns.clear();
    mRowData.clear();
  }
 
  size_t getNColumns() const { return mColumns.size(); }
 
  size_t getNRows() const { return mRowData.size(); }
 
  const RowDescType& getRowData(size_t row) const
  {
    if (row < mRowData.size()) {
      return mRowData[row];
    }
    // TODO: better to throw exception?
    static RowDescType dummy;
    return dummy;
  }
 
  // TODO:
  // instead of a member with this pointer of parent class, the access
  // function was supposed to be specified as a lambda. This definition
  // was supposed to be the type of the function member.
  // passing the access function to the iterator did not work because
  // the typedef for the access function is without the capture, so there
  // is no matching conversion.
  // Solution would be to use std::function but that's probably slow and
  // the function is called often. Can be checked later.
  typedef FrameData (*AccessFct)(unsigned, unsigned);
 
  class iterator
  { // TODO: derive from forward_iterator
   public:
    struct value_type : public FrameData {
      RowDescType desc;
    };
    using self_type = iterator;
 
    enum IteratorDirections {
      kAlongRow,
      kAlongColumn
    };
 
    iterator() = delete;
    ~iterator() = default;
    iterator(IteratorDirections direction, TableView* parent, unsigned row = 0, unsigned column = 0)
      : mDirection(direction), mRow(row), mColumn(column), mEnd(direction == kAlongRow ? parent->getNColumns() : parent->getNRows()), mParent(parent), mCache(), mIsCached(false)
    {
      while (!isValid() && !isEnd()) {
        operator++();
      }
    }
 
    self_type& operator++()
    {
      mIsCached = false;
      if (mDirection == kAlongRow) {
        if (mColumn < mEnd) {
          mColumn++;
        }
      } else {
        if (mRow < mEnd) {
          mRow++;
        }
      }
      while (!isEnd() && !isValid()) {
        operator++();
      }
      return *this;
    }
 
    value_type operator*() const
    {
      if (!mIsCached) {
        self_type* ncthis = const_cast<self_type*>(this);
        mParent->get(mRow, mColumn, ncthis->mCache);
        ncthis->mCache.desc = mParent->getRowData(mRow);
        ncthis->mIsCached = true;
      }
      return mCache;
    }
 
    bool operator==(const self_type& other) const
    {
      return mDirection == kAlongRow ? (mColumn == other.mColumn) : (mRow == other.mRow);
    }
 
    bool operator!=(const self_type& other) const
    {
      return mDirection == kAlongRow ? (mColumn != other.mColumn) : (mRow != other.mRow);
    }
 
    bool isEnd() const
    {
      return (mDirection == kAlongRow) ? (mColumn >= mEnd) : (mRow >= mEnd);
    }
 
    bool isValid() const
    {
      if (!mIsCached) {
        self_type* ncthis = const_cast<self_type*>(this);
        ncthis->mIsCached = mParent->get(mRow, mColumn, ncthis->mCache);
        ncthis->mCache.desc = mParent->getRowData(mRow);
      }
      return mIsCached;
    }
 
   protected:
    IteratorDirections mDirection;
    unsigned mRow;
    unsigned mColumn;
    unsigned mEnd;
    TableView* mParent;
    value_type mCache;
    bool mIsCached;
  };
 
  template <unsigned Direction>
  class outerIterator : public iterator
  {
   public:
    using base = iterator;
    using value_type = typename base::value_type;
    using self_type = outerIterator;
    static const unsigned direction = Direction;
 
    outerIterator() = delete;
    ~outerIterator() = default;
    outerIterator(TableView* parent, unsigned index)
      : iterator(typename iterator::IteratorDirections(direction), parent, direction == iterator::kAlongColumn ? index : 0, direction == iterator::kAlongRow ? index : 0)
    {
    }
 
    self_type& operator++()
    {
      if (base::mDirection == iterator::kAlongRow) {
        if (base::mColumn < base::mEnd) {
          base::mColumn++;
        }
      } else {
        if (base::mRow < base::mEnd) {
          base::mRow++;
        }
      }
      return *this;
    }
 
    iterator begin()
    {
      return iterator((base::mDirection == iterator::kAlongColumn) ? iterator::kAlongRow : iterator::kAlongColumn,
                      base::mParent,
                      (base::mDirection == iterator::kAlongColumn) ? base::mRow : 0,
                      (base::mDirection == iterator::kAlongRow) ? base::mColumn : 0);
    }
 
    iterator end()
    {
      return iterator((base::mDirection == iterator::kAlongColumn) ? iterator::kAlongRow : iterator::kAlongColumn,
                      base::mParent,
                      (base::mDirection == iterator::kAlongRow) ? base::mParent->getNRows() : 0,
                      (base::mDirection == iterator::kAlongColumn) ? base::mParent->getNColumns() : 0);
    }
  };
 
  using ColumnIterator = outerIterator<iterator::kAlongRow>;
  using RowIterator = outerIterator<iterator::kAlongColumn>;
 
  ColumnIterator begin()
  {
    return ColumnIterator(this, 0);
  }
 
  ColumnIterator end()
  {
    return ColumnIterator(this, mColumns.size());
  }
 
 private:
  bool get(unsigned row, unsigned column, FrameData& data)
  {
    if (this->mColumns.size() == 0) {
      return false;
    }
    auto element = this->mFrames.find(FrameIndex{this->mColumns[column], row});
    if (element != this->mFrames.end()) {
      data = element->second;
      return true;
    }
    return false;
  }
 
  std::map<FrameIndex, FrameData> mFrames;
  std::vector<ColumnIndexType> mColumns;
  std::vector<RowDescType> mRowData;
};
 
} // namespace algorithm
 
} // namespace o2
 
#endif // ALGORITHM_TABLEVIEW_H