table3d_values.h

Go to the documentation of this file.

 
#pragma once
 
#include "table3d_typedefs.h"
#include "preprocessor.h"
 
// ========================= INTRA-ROW ITERATION ========================= 
 
class table_row_iterator {
public:
 
    table_row_iterator(const table3d_value_t *pRowStart, table3d_dim_t rowWidth)
        : pValue(pRowStart), pEnd(pRowStart+rowWidth)  //cppcheck-suppress misra-c2012-10.4
    {
    }
 
    // LCOV_EXCL_START
    const table3d_value_t* end(void) const { return pEnd; }
    table3d_value_t* end(void) { return const_cast<table3d_value_t *>(pEnd); }
    // LCOV_EXCL_STOP
 
    table_row_iterator& advance(table3d_dim_t steps)
    { 
        pValue  = pValue + steps;
        return *this;
    }
 
    table_row_iterator& operator++(void)
    {
        return advance(1);
    }
 
    bool at_end(void) const
    {
        return pValue == pEnd;
    }
 
    // LCOV_EXCL_START
    const table3d_value_t& operator*(void) const
    {
        return *pValue;
    }
    table3d_value_t& operator*(void)
    {
        return *const_cast<table3d_value_t *>(pValue);
    }
    // LCOV_EXCL_STOP
 
    table3d_dim_t size(void) const { return pEnd-pValue; }
 
private:
    const table3d_value_t *pValue;
    const table3d_value_t *pEnd;
};
 
// ========================= INTER-ROW ITERATION ========================= 
 
class table_value_iterator
{
public:
 
    table_value_iterator(const table3d_value_t *pValues, table3d_dim_t axisSize)
        : pRowsStart(pValues),  //cppcheck-suppress misra-c2012-10.4
        rowWidth(axisSize)
    {
        // Table values are laid out conventionally - rows are in order
        // E.g. a 4x4 table with logical element [0][0] at the bottom left
        // (normal cartesian coordinates) has this layout.
        //  12  13  14  15
        //  8   9   10  11
        //  4   5   6   7
        //  0   1   2   3
        // So we start at row 0 (index 0 of the array) and iterate forward
    }
 
    table_value_iterator& advance(table3d_dim_t rows)
    {
        _row = _row + rows;
        return *this;
    }
 
    table_value_iterator& operator++(void)
    {
        return advance(1U);
    }
 
    table_row_iterator operator*(void) const
    {
        return table_row_iterator(pRowsStart + (_row*rowWidth), rowWidth);
    }
    table_row_iterator operator*(void)
    {
        return table_row_iterator(pRowsStart + (_row*rowWidth), rowWidth);
    }    
 
    bool at_end(void) const
    {
        return _row == rowWidth;
    }
 
private:
    const table3d_value_t *pRowsStart;
    table3d_dim_t _row = 0;
    table3d_dim_t rowWidth;
};
 
#define TABLE3D_TYPENAME_VALUE(size, xDom, yDom) CONCAT(TABLE3D_TYPENAME_BASE(size, xDom, yDom), _values)
 
#define TABLE3D_GEN_VALUES(size, xDom, yDom) \
 \
    struct TABLE3D_TYPENAME_VALUE(size, xDom, yDom) { \
 \
        static constexpr table3d_dim_t row_size = (size); \
 \
        static constexpr table3d_dim_t num_rows = (size); \
 \
        table3d_value_t values[(uint16_t)row_size*num_rows]; \
        \
 \
        table_value_iterator begin(void) \
        {  \
            return table_value_iterator(values, row_size); \
        } \
        \
 \
        table3d_value_t& value_at(table3d_dim_t linear_index) \
        { \
            return values[linear_index]; \
        } \
    };
TABLE3D_GENERATOR(TABLE3D_GEN_VALUES)