indexing_iterator.hpp

Go to the documentation of this file.

// Copyright 2024 Ekumen, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
#ifndef BELUGA_UTILITY_INDEXING_ITERATOR_HPP
#define BELUGA_UTILITY_INDEXING_ITERATOR_HPP
 
#include <cstdint>
#include <iterator>
#include <type_traits>
 
namespace beluga {
 
 
template <class Indexable, class Index = typename Indexable::size_type>
class IndexingIterator {
 public:
  using value_type =
      std::remove_cv_t<std::remove_reference_t<decltype(std::declval<Indexable>()[std::declval<Index>()])>>;
  using reference = decltype(std::declval<Indexable>()[std::declval<Index>()]);
  using pointer = decltype(std::addressof(std::declval<Indexable>()[std::declval<Index>()]));
  using difference_type = std::make_signed_t<decltype(std::declval<Index>() - std::declval<Index>())>;
  using iterator_category = std::random_access_iterator_tag;
 
  explicit IndexingIterator() = default;
 
  explicit IndexingIterator(Indexable* indexable, Index cursor = Index{})
      : indexable_{indexable}, cursor_{std::move(cursor)} {}
 
  explicit IndexingIterator(Indexable& indexable, Index cursor = Index{})
      : IndexingIterator(std::addressof(indexable), std::move(cursor)) {}
 
  IndexingIterator operator++(int) noexcept {
    IndexingIterator other = *this;
    ++(*this);
    return other;
  }
 
  IndexingIterator& operator++() noexcept {
    ++cursor_;
    return *this;
  }
 
  IndexingIterator operator--(int) noexcept {
    IndexingIterator other = *this;
    --(*this);
    return other;
  }
 
  IndexingIterator& operator--() noexcept {
    --cursor_;
    return *this;
  }
 
  IndexingIterator& operator+=(difference_type offset) noexcept {
    using raw_difference_type = decltype(cursor_ - cursor_);
    if (offset < 0) {
      cursor_ -= static_cast<raw_difference_type>(-offset);
    } else {
      cursor_ += static_cast<raw_difference_type>(offset);
    }
    return *this;
  }
 
  [[nodiscard]] IndexingIterator operator+(difference_type offset) const noexcept {
    IndexingIterator other = *this;
    other += offset;
    return other;
  }
 
  [[nodiscard]] friend IndexingIterator operator+(difference_type offset, const IndexingIterator& iterator) {
    return iterator + offset;
  }
 
  IndexingIterator& operator-=(difference_type offset) noexcept {
    using raw_difference_type = decltype(cursor_ - cursor_);
    if (offset < 0) {
      cursor_ += static_cast<raw_difference_type>(-offset);
    } else {
      cursor_ -= static_cast<raw_difference_type>(offset);
    }
    return *this;
  }
 
  [[nodiscard]] IndexingIterator operator-(difference_type offset) const noexcept {
    IndexingIterator other = *this;
    other -= offset;
    return other;
  }
 
  [[nodiscard]] difference_type operator-(const IndexingIterator& other) const noexcept {
    if (cursor_ < other.cursor_) {
      return -static_cast<difference_type>(other.cursor_ - cursor_);
    }
    return static_cast<difference_type>(cursor_ - other.cursor_);
  }
 
 
  [[nodiscard]] reference operator[](difference_type offset) const noexcept { return (*indexable_)[cursor_ + offset]; }
 
 
  [[nodiscard]] reference operator*() const noexcept { return (*indexable_)[cursor_]; }
 
 
  [[nodiscard]] pointer operator->() const noexcept { return std::addressof((*indexable_)[cursor_]); }
 
 
  bool operator<(const IndexingIterator& other) const noexcept {
    return indexable_ == other.indexable_ && cursor_ < other.cursor_;
  }
 
 
  bool operator<=(const IndexingIterator& other) const noexcept {
    return indexable_ == other.indexable_ && cursor_ <= other.cursor_;
  }
 
 
  bool operator>(const IndexingIterator& other) const noexcept { return !((*this) <= other); }
 
 
  bool operator>=(const IndexingIterator& other) const noexcept { return !((*this) < other); }
 
 
  bool operator==(const IndexingIterator& other) const noexcept {
    return indexable_ == other.indexable_ && cursor_ == other.cursor_;
  }
 
  bool operator!=(const IndexingIterator& other) const noexcept { return !(*this == other); }
 
 private:
  Indexable* indexable_{nullptr};
  Index cursor_{};
};
 
}  // namespace beluga
 
#endif