celllist.h

#pragma once

namespace Faunus {

namespace CellList {

namespace Grid {
template <typename T> using GridTypeOf = typename T::GridType;
template <typename T> using IndexOf = typename T::CellIndex;
template <typename T> using CoordOf = typename T::CellCoord;
template <typename T> using SpaceAxisOf = typename T::SpaceAxis;
template <typename T> using PointOf = typename T::Point;

template <unsigned int VDimension, std::integral TCellIndex = int,
          std::floating_point TSpaceAxis = double>
struct GridType
{
    constexpr static unsigned int Dimension =
        VDimension;               
    using SpaceAxis = TSpaceAxis; 
    using CellIndex =
        TCellIndex; 
    using Point = Eigen::Array<SpaceAxis, Dimension, 1>;     
    using CellCoord = Eigen::Array<CellIndex, Dimension, 1>; 
};

using Grid3DType = GridType<3, int, double>;

class GridOffsets3D
{
    using CellCoord = CoordOf<Grid3DType>; 
    using CellIndex = IndexOf<Grid3DType>; 
  public:
    const std::vector<CellCoord> self{{0, 0, 0}}; 
    std::vector<CellCoord> neighbors; 
    std::vector<CellCoord> forward_neighbors; 
    CellIndex distance; 

    explicit GridOffsets3D(CellIndex distance);

  private:
    void initNeighbors();
    void initForwardNeighbors();
};
} // namespace Grid

namespace Container {
template <typename T> using ContainerTypeOf = typename T::ContainerType;
template <typename T> using IndexOf = typename ContainerTypeOf<T>::Index;
template <typename T> using MemberOf = typename ContainerTypeOf<T>::Member;
template <typename T> using MembersOf = typename ContainerTypeOf<T>::Members;

template <typename TMember, typename TIndex> struct AbstractContainer
{
    using ContainerType = AbstractContainer<TMember, TIndex>;
    using Index = TIndex;                
    using Member = TMember;              
    using Members = std::vector<Member>; 

    virtual const Members& get(TIndex) const = 0;
    virtual Members& get(TIndex) = 0;
    virtual const Members& getEmpty() const = 0;
    virtual std::vector<TIndex> indices() const = 0;
    virtual ~AbstractContainer() = default;
};
} // namespace Container

template <typename T> using ContainerOf = typename T::Container;
template <typename T> using GridOf = typename T::Grid;
using Container::ContainerTypeOf;
using Grid::GridTypeOf;
template <typename T>
using IndexOf = typename Grid::IndexOf<GridTypeOf<typename T::AbstractCellList>>;
template <typename T>
using CoordOf = typename Grid::CoordOf<GridTypeOf<typename T::AbstractCellList>>;
template <typename T>
using PointOf = typename Grid::PointOf<GridTypeOf<typename T::AbstractCellList>>;
template <typename T>
using SpaceAxisOf = typename Grid::SpaceAxisOf<GridTypeOf<typename T::AbstractCellList>>;
template <typename T> using MemberOf = typename Container::MemberOf<typename T::AbstractCellList>;
template <typename T> using MembersOf = typename Container::MembersOf<typename T::AbstractCellList>;

template <class TContainerType, class TGridType> struct AbstractImmutableCellList
{
    using AbstractCellList = AbstractImmutableCellList<TContainerType, TGridType>; 
    using ContainerType = TContainerType;                         
    using GridType = TGridType;                                   
    using Members = typename Container::MembersOf<ContainerType>; 
    using Member = typename Container::MemberOf<ContainerType>;   
    using CellIndex = typename Grid::IndexOf<GridType>;           
    using CellCoord = typename Grid::CoordOf<GridType>;           

    virtual const Members& getMembers(const CellCoord&) = 0;
    virtual const Members& getNeighborMembers(const CellCoord&, const CellCoord&) = 0;
    virtual CellIndex gridSize() const = 0; // todo check if needed
    virtual std::vector<CellCoord> getCells() const = 0;
    virtual ~AbstractImmutableCellList() = default;
};

template <class TContainerType, class TGridType>
struct AbstractSortableCellList
    : virtual public AbstractImmutableCellList<TContainerType, TGridType>
{
    using typename AbstractImmutableCellList<TContainerType, TGridType>::AbstractCellList;
    using typename AbstractCellList::CellCoord;
    using typename AbstractCellList::Members;

    virtual const Members& getSortedMembers(const CellCoord&) = 0;
    virtual const Members& getNeighborSortedMembers(const CellCoord&, const CellCoord&) = 0;
    virtual ~AbstractSortableCellList() = default;
};
} // namespace CellList
} // namespace Faunus