#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;

/// FrameIndex is composed from column description and row number

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;

}

};

/// descriptor pointing to payload of one frame

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;

}

/// clear the index, i.e. all internal lists

void clear()

{

mFrames.clear();

mColumns.clear();

mRowData.clear();

}

/// get number of columns in the created index

size_t getNColumns() const { return mColumns.size(); }

/// get number of rows, i.e. number rows in the created index

size_t getNRows() const { return mRowData.size(); }

/// get row data for a data set

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);

/// Iterator class for configurable direction, i.e. either row or column

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;

};

/// iterator for the outer access of the index, either row or column direction

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;

}

/// begin the inner iteration

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);

}

/// end of the inner iteration

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);

}

};

/// definition of the outer iterator over column

using ColumnIterator = outerIterator<iterator::kAlongRow>;

/// definition of the outer iterator over row

using RowIterator = outerIterator<iterator::kAlongColumn>;

/// begin of the outer iteration

ColumnIterator begin()

{

return ColumnIterator(this, 0);

}

/// end of outer iteration

ColumnIterator end()

{

return ColumnIterator(this, mColumns.size());

}

private:

/// private access function for the iterators

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;

}

/// map of frame descriptors with key composed from header and row number

std::map<FrameIndex, FrameData> mFrames;

/// list of indices in row direction

std::vector<ColumnIndexType> mColumns;

/// data descriptor of each row forming the columns

std::vector<RowDescType> mRowData;

};

} // namespace algorithm

} // namespace o2

#endif // ALGORITHM_TABLEVIEW_H