RangeAccessor.hpp

Go to the documentation of this file.

#pragma once
 
#include <boost/iterator/iterator_facade.hpp>
 
namespace precice {
namespace mesh {
template <typename Source, typename Value>
class IndexRangeIterator : public boost::iterator_facade<
                               IndexRangeIterator<Source, const Value>,
                               const Value,
                               boost::random_access_traversal_tag> {
public:
  IndexRangeIterator() = default;
  IndexRangeIterator(Source *src, size_t index)
      : src_(src), idx_(index) {}
  IndexRangeIterator(Source *src, size_t index) {…}
 
  const Value &dereference() const
  {
    using Coord = decltype(src_->vertex(idx_).rawCoords());
    static_assert(
        std::is_reference<Coord>::value,
        "Coordinate type must be a reference!");
    static_assert(
        std::is_convertible<Coord, Value>::value,
        "Exposed and accessed types must match!");
    return static_cast<const Value &>(src_->vertex(idx_).rawCoords());
  }
  const Value &dereference() const {…}
 
  size_t equal(const IndexRangeIterator<Source, Value> &other) const
  {
    return other.idx_ == idx_ && other.src_ == src_;
  }
  size_t equal(const IndexRangeIterator<Source, Value> &other) const {…}
 
  void increment()
  {
    ++idx_;
  }
  void increment() {…}
 
  void decrement()
  {
    --idx_;
  }
  void decrement() {…}
 
  void advance(size_t n)
  {
    idx_ += n;
  }
  void advance(size_t n) {…}
 
  size_t distance_to(const IndexRangeIterator<Source, Value> &other) const
  {
    return other.idx_ - idx_;
  }
  size_t distance_to(const IndexRangeIterator<Source, Value> &other) const {…}
 
private:
  Source *src_{nullptr}; 
  size_t  idx_{0};       
};
class IndexRangeIterator : public boost::iterator_facade< {…};
 
} // namespace mesh
} // namespace precice