GridContainer.h

Go to the documentation of this file.

 
#ifndef GRIDCONTAINER_GRIDCONTAINER_H
#define GRIDCONTAINER_GRIDCONTAINER_H
 
#include "GridContainer/GridCellManagerTraits.h"
#include "GridContainer/GridIndexHelper.h"
#include "GridContainer/_impl/GridConstructionHelper.h"
#include <iterator>
#include <map>
#include <memory>
#include <tuple>
#include <type_traits>
 
namespace Euclid {
namespace GridContainer {

template <typename GridCellManager, typename... AxesTypes>
class GridContainer {
public:
  typedef typename GridCellManagerTraits<GridCellManager>::data_type      cell_type;
 
private:
  // The following aliases are used to simplify the definitions inside the class
  typedef typename GridCellManagerTraits<GridCellManager>::iterator cell_manager_iter_type;
 
  template <typename GCM>
  static cell_type* ptr_test(...);
 
  template<typename GCM>
  static typename GCM::pointer_type ptr_test(typename GCM::pointer_type*);
 
  template<typename GCM>
  static cell_type& ref_test(...);
 
  template<typename GCM>
  static typename GCM::reference_type ref_test(typename GCM::reference_type*);
 
public:
  typedef decltype(ptr_test<GridCellManagerTraits<GridCellManager>>(nullptr)) pointer_type;
  typedef decltype(ref_test<GridCellManagerTraits<GridCellManager>>(nullptr)) reference_type;

  typedef std::tuple<GridAxis<AxesTypes>...> AxesTuple;
 
  // The following is a shortcut to retrieve the type of each axis
  template <int I>
  using axis_type = typename std::tuple_element<I, std::tuple<AxesTypes...>>::type;
 
  // The iterator type of the GridContainer. See at the end of the file for its declaration
  template <typename CellType, typename PointerType, typename ReferenceType>
  class iter;
 
  typedef iter<cell_type, pointer_type, reference_type>                   iterator;
  typedef iter<cell_type const, pointer_type const, reference_type const> const_iterator;

  explicit GridContainer(GridAxis<AxesTypes>... axes);

  explicit GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple);

  template <typename... Args>
  GridContainer(std::tuple<GridAxis<AxesTypes>...> axes_tuple, Args&&... args);

  GridContainer(GridContainer<GridCellManager, AxesTypes...>&&) = default;
  GridContainer& operator=(GridContainer<GridCellManager, AxesTypes...>&&) = default;
 
  // Do not allow copying of GridContainer objects. This is done because these
  // objects will most of the time be very big and copying them will be a
  // bottleneck. To avoid involuntary copy constructor calls, this constructor
  // is deleted.
  GridContainer(const GridContainer<GridCellManager, AxesTypes...>&) = delete;
  GridContainer& operator=(const GridContainer<GridCellManager, AxesTypes...>&) = delete;

  GridContainer copy() const;

  virtual ~GridContainer() = default;

  static constexpr size_t axisNumber();

  template <int I>
  const GridAxis<axis_type<I>>& getAxis() const;

  const std::tuple<GridAxis<AxesTypes>...>& getAxesTuple() const;

  iterator begin();

  const_iterator begin() const;

  const_iterator cbegin();

  iterator end();

  const_iterator end() const;

  const_iterator cend();

  size_t size() const;

  const reference_type operator()(decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const;

  reference_type operator()(decltype(std::declval<GridAxis<AxesTypes>>().size())... indices);

  const reference_type at(decltype(std::declval<GridAxis<AxesTypes>>().size())... indices) const;

  reference_type at(decltype(std::declval<GridAxis<AxesTypes>>().size())... indices);

  std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...> infimum(const AxesTypes... coordinates) const;

  std::tuple<decltype(std::declval<GridAxis<AxesTypes>>().size())...>
  infimum(const std::tuple<AxesTypes...>& coordinates) const;

  template <int I>
  GridContainer<GridCellManager, AxesTypes...> fixAxisByIndex(size_t index);

  template <int I>
  const GridContainer<GridCellManager, AxesTypes...> fixAxisByIndex(size_t index) const;

  template <int I>
  GridContainer<GridCellManager, AxesTypes...> fixAxisByValue(const axis_type<I>& value);

  template <int I>
  const GridContainer<GridCellManager, AxesTypes...> fixAxisByValue(const axis_type<I>& value) const;
 
  GridCellManager& getCellManager() {
    return *m_cell_manager;
  }
 
  const GridCellManager& getCellManager() const {
    return *m_cell_manager;
  }
 
private:
  std::tuple<GridAxis<AxesTypes>...> m_axes;
  GridIndexHelper<AxesTypes...> m_index_helper{m_axes};
  std::tuple<GridAxis<AxesTypes>...> m_axes_fixed{m_axes};
  GridIndexHelper<AxesTypes...> m_index_helper_fixed{m_axes_fixed};
  std::map<size_t, size_t> m_fixed_indices{};
  std::shared_ptr<GridCellManager> m_cell_manager;

  GridContainer();

  GridContainer(const GridContainer<GridCellManager, AxesTypes...>& other, size_t axis, size_t index);

  template <int I>
  const GridAxis<axis_type<I>>& getOriginalAxis() const;
 
};  // end of class GridContainer

template <typename GridCellManager, typename... AxesTypes>
template <typename CellType, typename PointerType, typename ReferenceType>
class GridContainer<GridCellManager, AxesTypes...>::iter
    : public std::iterator<std::forward_iterator_tag, CellType, std::ptrdiff_t, PointerType, ReferenceType> {
public:
  iter(const GridContainer<GridCellManager, AxesTypes...>& owner, const cell_manager_iter_type& data_iter);

  iter(const iter&) = default;

  iter(iter&&) = default;

  iter& operator=(const iter& other);

  iter& operator++();

  ReferenceType operator*();

  typename std::add_const<ReferenceType>::type operator*() const;

  PointerType operator->();

  typename std::add_const<PointerType>::type operator->() const;

  bool operator==(const iter& other) const;

  bool operator!=(const iter& other) const;

  template <int I>
  size_t axisIndex() const;

  template <int I>
  const axis_type<I>& axisValue() const;

  template <int I>
  iter& fixAxisByIndex(size_t index);

  template <int I>
  iter& fixAxisByValue(const axis_type<I>& value);

  template <typename OtherIter>
  iter& fixAllAxes(const OtherIter& other);
 
private:
  const GridContainer<GridCellManager, AxesTypes...>& m_owner;
  cell_manager_iter_type                              m_data_iter;
  std::map<size_t, size_t>                            m_fixed_indices;
  void                                                forwardToIndex(size_t axis, size_t fixed_index);
 
};  // end of class iter
 
}  // end of namespace GridContainer
}  // end of namespace Euclid
 
#include "GridContainer/_impl/GridContainer.icpp"
#include "GridContainer/_impl/GridIterator.icpp"
 
#endif /* GRIDCONTAINER_GRIDCONTAINER_H */