CellIterator.h

Go to the documentation of this file.

 
#pragma once
 
#include <type_traits>
#include <vector>
 
template <class StorageType, bool modifiable>
class CellIterator {
 public:
  using IteratorType =
      std::conditional_t<modifiable, typename StorageType::iterator, typename StorageType::const_iterator>;
 
  using ParticleType = std::remove_pointer_t<typename StorageType::value_type>;
 
  using difference_type = typename IteratorType::difference_type;
  using value_type = typename IteratorType::value_type;
  using pointer = typename IteratorType::pointer;
  using reference = typename IteratorType::reference;
  using iterator_category = typename IteratorType::iterator_category;
 
  explicit CellIterator(IteratorType iterator) : iterator(iterator) {}
 
  inline std::conditional_t<modifiable, ParticleType &, const ParticleType &> operator*() const {
    using RetType = ParticleType &;
    // depending on the cell the iterator points to a particle or pointer
    // resolve this at compile time
    if constexpr (std::is_same_v<std::remove_const_t<std::remove_reference_t<RetType>>,
                                 std::remove_const_t<std::remove_reference_t<decltype(*iterator)>>>) {
      return *iterator;
    } else if constexpr (std::is_same_v<std::remove_const_t<std::remove_reference_t<RetType>>,
                                        std::remove_const_t<std::remove_reference_t<decltype(**iterator)>>>) {
      return **iterator;
    } else {
      // trigger compile error that prints the type of *iterator
      return decltype(*iterator)::thisMemberDoesntExist;
    }
  }
 
  inline std::conditional_t<modifiable, ParticleType *, const ParticleType *> operator->() const {
    return &operator*();
  }
 
  inline CellIterator<StorageType, modifiable> &operator++() {
    ++iterator;
    return *this;
  }
 
  inline CellIterator<StorageType, modifiable> &operator--() {
    --iterator;
    return *this;
  }
 
  bool operator==(const CellIterator &rhs) const { return iterator == rhs.iterator; }
  bool operator!=(const CellIterator &rhs) const { return not(*this == rhs); }
 
  difference_type operator-(const CellIterator &rhs) const { return iterator - rhs.iterator; }
 
  bool operator<(const CellIterator &rhs) const { return iterator < rhs; }
 
 private:
  IteratorType iterator;
};