GridContainers.h

Go to the documentation of this file.

#ifndef LARDATA_UTILITIES_GRIDCONTAINERS_H
#define LARDATA_UTILITIES_GRIDCONTAINERS_H

// LArSoft libraries
#include "lardata/Utilities/GridContainerIndices.h"

// C/C++ standard libraries
#include <array>
#include <vector>

namespace util {

  namespace details {

    template <typename DATUM, typename IXMAN>
    class GridContainerBase {

    public:
      using Datum_t = DATUM;   
      using Indexer_t = IXMAN; 

      using Grid_t = GridContainerBase<Datum_t, Indexer_t>; 

      static constexpr unsigned int dims() { return IXMAN::dims(); }

      using CellIndex_t = typename Indexer_t::CellIndex_t;

      using CellIndexOffset_t = typename Indexer_t::CellIndexOffset_t;

      using CellDimIndex_t = typename Indexer_t::CellDimIndex_t;

      using CellID_t = typename Indexer_t::CellID_t;

      using Cell_t = std::vector<Datum_t>;

      using Cells_t = std::vector<Cell_t>;

      using const_iterator = typename Cells_t::const_iterator;

      GridContainerBase(std::array<size_t, dims()> const& dims)
        : indices(dims), data(indices.size())
      {}


      size_t size() const { return indices.size(); }

      bool has(CellIndexOffset_t index) const { return indices.has(index); }



      CellIndex_t index(CellID_t const& id) const { return indices[id]; }

      CellIndexOffset_t indexOffset(CellID_t const& origin, CellID_t const& cellID) const
      {
        return indices.offset(origin, cellID);
      }

      Cell_t& operator[](CellID_t const& id) { return cell(id); }

      Cell_t const& operator[](CellID_t const& id) const { return cell(id); }

      Cell_t& operator[](CellIndex_t index) { return data[index]; }

      Cell_t const& operator[](CellIndex_t index) const { return data[index]; }



      void insert(CellID_t const& cellID, Datum_t const& elem) { cell(cellID).push_back(elem); }

      void insert(CellID_t const& cellID, Datum_t&& elem)
      {
        cell(cellID).push_back(std::move(elem));
      }

      void insert(CellIndex_t index, Datum_t const& elem) { data[index].push_back(elem); }

      void insert(CellIndex_t index, Datum_t&& elem) { data[index].push_back(std::move(elem)); }


      Indexer_t const& indexManager() const { return indices; }

    protected:
      Indexer_t indices; 

      Cells_t data; 

      Cell_t& cell(CellID_t const& cellID) { return data[index(cellID)]; }

      Cell_t const& cell(CellID_t const& cellID) const { return data[index(cellID)]; }

    }; // GridContainerBase<>

  } // namespace details

  template <typename DATUM, typename IXMAN>
  class GridContainerBase1D : public details::GridContainerBase<DATUM, IXMAN> {
    using Base_t = details::GridContainerBase<DATUM, IXMAN>;
    static_assert(Base_t::dims() >= 1, "GridContainerBase1D must have dimensions 1 or larger.");

  public:
    using Base_t::GridContainerBase;


    bool hasX(typename Base_t::CellDimIndex_t index) const { return Base_t::indices.hasX(index); }

    size_t sizeX() const { return Base_t::indices.sizeX(); }


  protected:
  }; // GridContainerBase1D<>

  template <typename DATUM, typename IXMAN>
  class GridContainerBase2D : public GridContainerBase1D<DATUM, IXMAN> {
    using Base_t = GridContainerBase1D<DATUM, IXMAN>;
    static_assert(Base_t::dims() >= 2, "GridContainerBase2D must have dimensions 2 or larger.");

  public:
    using Base_t::GridContainerBase1D;


    size_t sizeY() const { return Base_t::indices.sizeY(); }

    bool hasY(typename Base_t::CellDimIndex_t index) const { return Base_t::indices.hasY(index); }


  protected:
  }; // GridContainerBase2D<>

  template <typename DATUM, typename IXMAN>
  class GridContainerBase3D : public GridContainerBase2D<DATUM, IXMAN> {
    using Base_t = GridContainerBase2D<DATUM, IXMAN>;
    static_assert(Base_t::dims() >= 3, "GridContainerBase3D must have dimensions 3 or larger.");

  public:
    using Base_t::GridContainerBase2D;


    size_t sizeZ() const { return Base_t::indices.sizeZ(); }

    bool hasZ(typename Base_t::CellDimIndex_t index) const { return Base_t::indices.hasZ(index); }


  protected:
  }; // GridContainerBase3D<>

  template <typename DATUM>
  using GridContainer2D = GridContainerBase2D<DATUM, GridContainer2DIndices>;

  template <typename DATUM>
  using GridContainer3D = GridContainerBase3D<DATUM, GridContainer3DIndices>;

} // namespace util

#endif // LARDATA_UTILITIES_GRIDCONTAINERS_H