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 <vector>
#include <array>


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