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 + (axisSize*(axisSize-1U))),  //cppcheck-suppress misra-c2012-10.4
        pRowsEnd(pValues - axisSize),
        rowWidth(axisSize)
    {
        // Table values are not linear in memory - rows are in reverse order
        // E.g. a 4x4 table with logical element [0][0] at the bottom left
        // (normal cartesian coordinates) has this layout.
        //  0   1   2   3
        //  4   5   6   7
        //  8   9   10  11
        //  12  13  14  15
        // So we start at row 3 (index 12 of the array) and iterate towards
        // the start of the array
        //
        // This all supports fast 3d interpolation.
    }
 
    table_value_iterator& advance(table3d_dim_t rows)
    {
        pRowsStart = pRowsStart - (rowWidth * rows);
        return *this;
    }
 
    table_value_iterator& operator++(void)
    {
        return advance(1U);
    }
 
    table_row_iterator operator*(void) const
    {
        return table_row_iterator(pRowsStart, rowWidth);
    }
    table_row_iterator operator*(void)
    {
        return table_row_iterator(pRowsStart, rowWidth);
    }    
 
    bool at_end(void) const
    {
        return pRowsStart == pRowsEnd;
    }
 
private:
    const table3d_value_t *pRowsStart;
    const table3d_value_t *pRowsEnd;
    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) \
        { \
            static_assert(row_size<17U, "Table is too big"); \
            static_assert(num_rows<17U, "Table is too big"); \
            /* Zero length will mess up unsigned calcs */ \
            static_assert(row_size>0U, "No zero length rows"); \
            static_assert(num_rows>0U, "No empty tables"); \
            constexpr table3d_dim_t first_index = row_size*(table3d_dim_t)(num_rows-1U); \
            const table3d_dim_t index = (table3d_dim_t)(first_index + (table3d_dim_t)(2U*(linear_index % row_size)) - linear_index); \
            return values[index]; \
        } \
    };
TABLE3D_GENERATOR(TABLE3D_GEN_VALUES)