fsGrid.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           fsGrid.h
*
*       Purpose:        Template class for 2d grid
*
*********************************************************************/
 
#ifndef fsGridhdr
#define fsGridhdr
 
#include <vector>
#include <functional>
#include <algorithm>
 
#include "fsBaseTypes.h"
#include "fsPoint.h"
 
 
template <typename fsTCell>
class fsGrid
{
public:
 
        fsBool onGrid(fsPoint const& pPos) const
        {
                const auto hs = halfCell();
                return
                        pPos.x >= mOrigin.x - hs.x
                        && pPos.x < mOrigin.x - hs.x + rowStrideGet() * mDimensions.x
                        && pPos.y >= mOrigin.y - hs.y
                        && pPos.y < mOrigin.y - hs.y + columnStrideGet() * mDimensions.y;
        }
 
        fsPoint worlddLocation(fsPoint const& pGridPos) const
        {
                return {
                        originGet().x + pGridPos.x * cellBorderedDimensionsGet().x,
                        originGet().y + pGridPos.y * cellBorderedDimensionsGet().y
                };
        }
 
        fsPoint gridLocation(fsPoint const& pPos) const
        {
                return {
                        (pPos.x - originGet().x + halfCell().x) / cellBorderedDimensionsGet().x,
                        (pPos.y - originGet().y + halfCell().y) / cellBorderedDimensionsGet().y
                };
        }
 
        fsPoint halfCell() const
        {
                return (mCellDimensions + mCellBorder) / 2;
        }
 
        fsTCell& getCell(fsS32 pColumn, fsS32 pRow);
        fsPoint const& cellDimensionsGet() const { return mCellDimensions; }
        fsPoint cellBorderedDimensionsGet() const { return mCellDimensions + mCellBorder; }
 
        fsS32 columnsGet() const { return mDimensions.x; }
        fsS32 rowsGet() const { return mDimensions.y; }
 
        fsS32 rowStrideGet() const { return mCellDimensions.x + mCellBorder.x; }
        fsS32 columnStrideGet() const { return mCellDimensions.y + mCellBorder.y; }
 
        fsPoint const& originGet() const { return mOrigin; }
 
        typename std::vector<fsTCell>::iterator begin() { return mCells.begin(); }
        typename std::vector<fsTCell>::iterator end() { return mCells.end(); }
        typename std::vector<fsTCell>::reverse_iterator rbegin() { return mCells.rbegin(); }
        typename std::vector<fsTCell>::reverse_iterator rend() { return mCells.rend(); }
 
        void drop(std::function<void(fsTCell, fsTCell)> pAction);
 
        void swap(fsTCell pLHS, fsTCell pRHS);
 
        typename std::vector<fsTCell>::iterator
        findIf(typename std::vector<fsTCell>::iterator pBegin, typename std::vector<fsTCell>::iterator pEnd,
               std::function<fsBool(fsTCell)> pPredicate);
 
        template <typename FwdIt>
        void forEachRow(FwdIt pBegin, FwdIt pEnd,
                        std::function<void(fsTCell)> pCellAction, std::function<void()> pRowAction);
        template <typename FwdIt>
        void forEachColumn(FwdIt pBegin, FwdIt pEnd,
                           std::function<void(fsTCell)> pCellAction, std::function<void()> pColumnAction);
        template <typename FwdIt>
        void forEachDescendingDiagonal(FwdIt pBegin, FwdIt pEnd,
                                       std::function<void(fsTCell)> pCellAction, std::function<void()> pDiagonalAction);
        template <typename FwdIt>
        void forEachAscendingDiagonal(FwdIt pBegin, FwdIt pEnd,
                                      std::function<void(fsTCell)> pCellAction, std::function<void()> pDiagonalAction);
 
 
        void forEach(fsPoint const& pBegin, fsPoint const& pEnd,
                     std::function<void(fsTCell&)> pCellOperation);
 
        void forEach(typename std::vector<fsTCell>::iterator pBegin, typename std::vector<fsTCell>::iterator pEnd,
                     std::function<void(fsTCell&)> pCellOperation);
 
        void generate(std::function<fsTCell const(fsS32, fsS32)> pCellCreate);
 
        void init(fsPoint const& pOrigin, fsPoint const& pDimensions, fsPoint const& pCellDimensions,
                  fsPoint const& pCellBorder);
 
        fsGrid() = default;
        ~fsGrid() = default;
 
protected:
 
private:
 
        std::vector<fsTCell> mCells;
 
        fsPoint mDimensions;
        fsPoint mOrigin;
 
        fsPoint mCellDimensions;
        fsPoint mCellBorder;
};
 
 
template <typename fsTCell>
fsTCell& fsGrid<fsTCell>::getCell(fsS32 pColumn, fsS32 pRow)
{
        return mCells[pColumn + pRow * mDimensions.x];
}
 
template <typename fsTCell>
void fsGrid<fsTCell>::init(fsPoint const& pOrigin, fsPoint const& pDimensions, fsPoint const& pCellDimensions,
                           fsPoint const& pCellBorder)
{
        mDimensions = pDimensions;
        mOrigin = pOrigin;
        mCellDimensions = pCellDimensions;
        mCellBorder = pCellBorder;
        mCells.resize(mDimensions.x * mDimensions.y);
}
 
 
template <typename fsTCell>
typename std::vector<fsTCell>::iterator
fsGrid<fsTCell>::findIf(typename std::vector<fsTCell>::iterator pBegin, typename std::vector<fsTCell>::iterator pEnd,
                        std::function<fsBool(fsTCell)> pPredicate)
{
        return std::find_if(pBegin, pEnd, pPredicate);
}
 
template <typename fsTCell>
void fsGrid<fsTCell>::forEach(fsPoint const& pBegin, fsPoint const& pEnd,
                              std::function<void(fsTCell&)> pCellOperation)
{
        if(pEnd.y >= pBegin.y)
        {
                if(pEnd.x >= pBegin.x)
                {
                        for (fsS32 j = pBegin.y; j <= pEnd.y; ++j)
                        {
                                for (fsS32 i = pBegin.x; i <= pEnd.x; ++i)
                                {
                                        pCellOperation(getCell(i, j));
                                }
                        }
                }
                else
                {
                        for (fsS32 j = pBegin.y; j <= pEnd.y; ++j)
                        {
                                for (fsS32 i = pBegin.x; i >= pEnd.x; --i)
                                {
                                        pCellOperation(getCell(i, j));
                                }
                        }
                }               
        }
        else
        {
                {
                        if(pEnd.x >= pBegin.x)
                        {
                                for (fsS32 j = pBegin.y; j >= pEnd.y; --j)
                                {
                                        for (fsS32 i = pBegin.x; i <= pEnd.x; ++i)
                                        {
                                                pCellOperation(getCell(i, j));
                                        }
                                }
                        }
                        else
                        {
                                for (fsS32 j = pBegin.y; j >= pEnd.y; --j)
                                {
                                        for (fsS32 i = pBegin.x; i >= pEnd.x; --i)
                                        {
                                                pCellOperation(getCell(i, j));
                                        }
                                }
                        }               
                }
        }
}
 
template <typename fsTCell>
void fsGrid<fsTCell>::forEach(typename std::vector<fsTCell>::iterator pBegin,
                              typename std::vector<fsTCell>::iterator pEnd,
                              std::function<void(fsTCell&)> pCellOperation)
{
        std::for_each(pBegin, pEnd, pCellOperation);
}
 
template <typename fsTCell>
void fsGrid<fsTCell>::generate(std::function<fsTCell const(fsS32, fsS32)> pCellCreate)
{
        fsS32 i = 0;
        std::generate(mCells.begin(), mCells.end(),
                      [&]()
                      {
                              const fsS32 col = i % mDimensions.x;
                              const fsS32 row = i++ / mDimensions.x;
                              return pCellCreate(col, row);
                      });
}
 
template <typename fsTCell>
void fsGrid<fsTCell>::swap(fsTCell const pLHS, fsTCell const pRHS)
{
        std::iter_swap(std::find(mCells.begin(), mCells.end(), pLHS),
                       std::find(mCells.begin(), mCells.end(), pRHS));
}
 
template <typename fsTCell>
template <typename FwdIt>
void fsGrid<fsTCell>::forEachRow(FwdIt pBegin, FwdIt pEnd,
                                 std::function<void(fsTCell)> pCellAction, std::function<void()> pRowAction)
{
        FwdIt rowStart = pBegin;
        FwdIt rowEnd = pBegin;
        std::advance(rowEnd, mDimensions.x);
 
        while (rowEnd != pEnd)
        {
                std::for_each(rowStart, rowEnd, pCellAction);
                std::advance(rowStart, mDimensions.x);
                std::advance(rowEnd, mDimensions.x);
                pRowAction();
        }
        std::for_each(rowStart, rowEnd, pCellAction);
        pRowAction();
}
 
 
template <typename fsTCell>
template <typename FwdIt>
void fsGrid<fsTCell>::forEachColumn(FwdIt pBegin, FwdIt pEnd,
                                    std::function<void(fsTCell)> pCellAction, std::function<void()> pColumnAction)
{
        FwdIt columnStart = pBegin;
        FwdIt columnEnd = pEnd;
        std::advance(columnEnd, -mDimensions.x);
 
        while (columnEnd != pEnd)
        {
                FwdIt it = columnStart;
                while (it != columnEnd)
                {
                        pCellAction(*it);
                        it += mDimensions.x;
                }
 
                pCellAction(*it);
                pColumnAction();
                ++columnStart;
                ++columnEnd;
        }
}
 
template <typename fsTCell>
template <typename FwdIt>
void fsGrid<fsTCell>::forEachDescendingDiagonal(FwdIt pBegin, FwdIt pEnd,
                                                std::function<void(fsTCell)> pCellAction,
                                                std::function<void()> pDiagonalAction)
{
        FwdIt columnStart = pBegin;
        FwdIt columnEnd = pEnd;
        --columnEnd;
 
        while (columnStart != columnEnd)
        {
                FwdIt it = columnStart;
                while (it != columnEnd)
                {
                        pCellAction(*it);
                        it += mDimensions.x + 1;
                }
 
                pCellAction(*it);
                pDiagonalAction();
                ++columnStart;
                columnEnd -= mDimensions.x;
        }
 
        columnStart = pBegin;
        columnEnd = pEnd;
        --columnEnd;
 
        columnStart += mDimensions.x;
        --columnEnd;
 
        while (columnStart != columnEnd)
        {
                FwdIt it = columnStart;
                while (it != columnEnd)
                {
                        pCellAction(*it);
                        it += mDimensions.x + 1;
                }
 
                pCellAction(*it);
                pDiagonalAction();
                columnStart += mDimensions.x;
                --columnEnd;
        }
}
 
template <typename fsTCell>
template <typename FwdIt>
void fsGrid<fsTCell>::forEachAscendingDiagonal(FwdIt pBegin, FwdIt pEnd,
                                               std::function<void(fsTCell)> pCellAction,
                                               std::function<void()> pDiagonalAction)
{
        FwdIt columnStart = pEnd;
        FwdIt columnEnd = pBegin;
 
        std::advance(columnStart, -mDimensions.x);
        std::advance(columnEnd, mDimensions.x - 1);
 
        while (columnStart != columnEnd)
        {
                FwdIt it = columnStart;
                while (it != columnEnd)
                {
                        pCellAction(*it);
                        it -= mDimensions.x - 1;
                }
 
                pCellAction(*it);
                pDiagonalAction();
                --columnEnd;
                columnStart -= mDimensions.x;
        }
 
        columnStart = pEnd;
        columnEnd = pBegin;
 
        std::advance(columnStart, -mDimensions.x);
        std::advance(columnEnd, mDimensions.x - 1);
 
        while (columnStart != columnEnd)
        {
                FwdIt it = columnStart;
                while (it != columnEnd)
                {
                        pCellAction(*it);
                        it -= mDimensions.x - 1;
                }
 
                pCellAction(*it);
                pDiagonalAction();
                ++columnStart;
                columnEnd += mDimensions.x;
        }
}
 
template <typename fsTCell>
void fsGrid<fsTCell>::drop(
        std::function<void(fsTCell, fsTCell)> pAction)
{
        typename std::vector<fsTCell>::iterator it = mCells.begin();
        typename std::vector<fsTCell>::iterator itBelow = mCells.begin();
        std::advance(itBelow, mDimensions.x);
 
        typename std::vector<fsTCell>::iterator limit = mCells.begin();
        std::advance(limit, std::distance(mCells.begin(), mCells.end()) - mDimensions.x);
 
        while (it < limit)
        {
                pAction(*it, *itBelow);
 
                ++it;
                ++itBelow;
        }
}
 
#endif