Iterators.hpp

// Copyright (c) 2018 Graphcore Ltd. All rights reserved.
 
#ifndef _poplar_Iterators_hpp_
#define _poplar_Iterators_hpp_
 
#include <iterator>
 
#include <poplar/Alignment.hpp>
 
namespace poplar {
 
// Forward iterator.
template <typename T>
class ForwardIterator
    : public std::iterator<std::forward_iterator_tag, const T> {
  const T **p;
 
public:
  ForwardIterator(void **q) { p = (const T **)q; }
  const T &operator*() const { return **p; }
  const T *operator->() const { return *p; }
  bool operator==(const ForwardIterator &y) const { return p == y.p; }
  bool operator!=(const ForwardIterator &y) const { return p != y.p; }
  ForwardIterator &operator++() {
    p++;
    return *this;
  }
  ForwardIterator operator++(int) {
    ForwardIterator it(*this);
    p++;
    return it;
  }
};
 
template <typename T>
using StdRandomAccessIterator =
    std::iterator<std::random_access_iterator_tag, const T>;
 
// Dereferencing random-access iterator.
template <typename T, unsigned MinAlign>
class DerefRandomAccessIterator : public StdRandomAccessIterator<T> {
  friend DerefRandomAccessIterator<const T, MinAlign>;
  T *const *p;
 
public:
  using typename StdRandomAccessIterator<T>::difference_type;
  using reference = T &;
  explicit DerefRandomAccessIterator(T **q) : p(q) {}
  DerefRandomAccessIterator(
      const DerefRandomAccessIterator<typename std::remove_const<T>::type,
                                      MinAlign> &other)
      : p(other.p) {}
  T &operator*() const { return *poplar_assume_aligned<MinAlign, T>(*p); }
  T *operator->() const { return poplar_assume_aligned<MinAlign, T>(*p); }
  DerefRandomAccessIterator &
  operator=(const DerefRandomAccessIterator &) = default;
  DerefRandomAccessIterator &operator++() {
    p++;
    return *this;
  }
  DerefRandomAccessIterator operator++(int) {
    DerefRandomAccessIterator it(*this);
    p++;
    return it;
  }
  DerefRandomAccessIterator &operator--() {
    p--;
    return *this;
  }
  DerefRandomAccessIterator operator--(int) {
    DerefRandomAccessIterator it(*this);
    p--;
    return it;
  }
  DerefRandomAccessIterator &operator+=(const difference_type &n) {
    p += n;
    return *this;
  }
  friend const DerefRandomAccessIterator
  operator+(const difference_type &n, DerefRandomAccessIterator out) {
    out += n;
    return out;
  }
  friend const DerefRandomAccessIterator
  operator+(DerefRandomAccessIterator out, const difference_type &n) {
    out += n;
    return out;
  }
  DerefRandomAccessIterator &operator-=(const difference_type &n) {
    p -= n;
    return *this;
  }
  DerefRandomAccessIterator operator-(const difference_type &n) const {
    DerefRandomAccessIterator it(*this);
    return it -= n;
  }
  reference operator[](const difference_type &n) const {
    return *poplar_assume_aligned<MinAlign, T>(p[n]);
  }
  friend difference_type operator-(const DerefRandomAccessIterator &a,
                                   const DerefRandomAccessIterator &b) {
    return a.p - b.p;
  }
  friend bool operator==(const DerefRandomAccessIterator &a,
                         const DerefRandomAccessIterator &b) {
    return a.p == b.p;
  }
  friend bool operator!=(const DerefRandomAccessIterator &a,
                         const DerefRandomAccessIterator &b) {
    return a.p != b.p;
  }
  friend bool operator<(const DerefRandomAccessIterator &a,
                        const DerefRandomAccessIterator &b) {
    return a.p < b.p;
  }
  friend bool operator>(const DerefRandomAccessIterator &a,
                        const DerefRandomAccessIterator &b) {
    return a.p > b.p;
  }
  friend bool operator<=(const DerefRandomAccessIterator &a,
                         const DerefRandomAccessIterator &b) {
    return a.p <= b.p;
  }
  friend bool operator>=(const DerefRandomAccessIterator &a,
                         const DerefRandomAccessIterator &b) {
    return a.p >= b.p;
  }
}; // End DerefRandomAccessIterator.
 
} // namespace poplar
 
#endif // _poplar_Iterators_hpp_