iterators.hpp

Go to the documentation of this file.

/* Copyright 2017 - 2026 R. Thomas
 * Copyright 2017 - 2026 Quarkslab
 * Copyright 2017 - 2021, NVIDIA CORPORATION. All rights reserved.
 *
 * 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 LIEF_ITERATORS_H
#define LIEF_ITERATORS_H
#include <type_traits>
#include <algorithm>
#include <cassert>
#include <cstddef>
#include <functional>
#include <iterator>
#include <memory>
#include <vector>
 
#include "LIEF/compiler_attributes.hpp"
 
namespace LIEF {
 
template<class T>
using decay_t = std::decay_t<T>;
 
template<class T>
using add_const_t = std::add_const_t<T>;
 
template<class T>
using remove_const_t = std::remove_const_t<T>;
 
template<class T>
using add_lvalue_reference_t = std::add_lvalue_reference_t<T>;
 
namespace details {
template<class T, bool = std::is_reference_v<T>>
class container_storage {
  public:
  using container_t = std::remove_reference_t<T>;
  using arg_t = T;
 
  container_storage() = default;
  explicit container_storage(arg_t container) :
    container_{std::addressof(container)} {}

  container_t* get() const {
    return container_;
  }
 
  private:
  container_t* container_ = nullptr;
};
 
template<class T>
class container_storage<T, false> {
  public:
  using container_t = std::remove_const_t<T>;
  using arg_t = container_t;
 
  container_storage() = default;
  explicit container_storage(arg_t container) :
    container_(std::move(container)) {}
 
  container_t* get() const {
    return &container_;
  }
 
  private:
  mutable container_t container_;
};
 
template<class T>
using container_arg_t = typename container_storage<T>::arg_t;
 
template<class Ref, class U, class IT>
Ref deref(const IT& it) {
  if constexpr (std::is_pointer_v<U>) {
    assert(*it && "integrity error: nullptr");
    return static_cast<Ref>(**it);
  } else {
    return const_cast<Ref>(*it);
  }
}
 
template<class T, class U, class Category>
using iterator_concept_t =
    std::conditional_t<std::is_reference_v<T> || std::is_pointer_v<U>, Category,
                       std::input_iterator_tag>;
}

template<class T, typename U = typename decay_t<T>::value_type,
         class ITERATOR_T = typename decay_t<T>::iterator>
class ref_iterator {
  template<class, typename, class>
  friend class ref_iterator;
 
  public:
  using iterator_category = std::bidirectional_iterator_tag;
  using iterator_concept =
      details::iterator_concept_t<T, U, std::bidirectional_iterator_tag>;
  using value_type = std::remove_cv_t<std::remove_pointer_t<decay_t<U>>>;
  using difference_type = ptrdiff_t;
  using pointer = std::remove_pointer_t<U>*;
  using reference = std::remove_pointer_t<U>&;
 
  using container_type = T; // e.g. std::vector<Section*>&
  using DT_VAL = U;         // e.g. Section*
  using DT = decay_t<T>;    // e.g. std::vector<Section>
  using ref_t = typename ref_iterator::reference;
  using pointer_t = typename ref_iterator::pointer;
 
  ref_iterator() = default;
 
  ref_iterator(const ref_iterator& other) :
    container_{other.container_},
    it_{other.it_},
    distance_{other.distance_} {
    rebase();
  }
 
  ref_iterator(ref_iterator&& other) noexcept :
    container_{std::move(other.container_)},
    it_{other.it_},
    distance_{other.distance_} {
    rebase();
    other.container_ = {};
    other.it_ = {};
    other.distance_ = 0;
  }
 
  ref_iterator& operator=(const ref_iterator& other) LIEF_LIFETIMEBOUND {
    ref_iterator copy{other};
    swap(copy);
    return *this;
  }
 
  ref_iterator& operator=(ref_iterator&& other) noexcept LIEF_LIFETIMEBOUND {
    swap(other);
    return *this;
  }
 
  template<class T2, typename U2, class IT2,
           typename = std::enable_if_t<
               !std::is_same_v<ref_iterator, ref_iterator<T2, U2, IT2>> &&
               std::is_same_v<decay_t<T>, decay_t<T2>>
           >>
  ref_iterator(const ref_iterator<T2, U2, IT2>& other) :
    distance_{other.distance_} {
    if (auto* container = other.container_.get(); container != nullptr) {
      if constexpr (std::is_reference_v<T>) {
        container_ = details::container_storage<T>{const_cast<T>(*container)};
      } else {
        container_ = details::container_storage<T>{*container};
      }
      it_ = std::next(std::begin(*container_.get()), distance_);
    }
  }
 
  ~ref_iterator() = default;
 
  // NOLINTNEXTLINE(performance-unnecessary-value-param)
  ref_iterator(details::container_arg_t<T> container) :
    container_{std::forward<details::container_arg_t<T>>(container)},
    it_(std::begin(*container_.get())) {}
 
  void swap(ref_iterator& other) noexcept {
    std::swap(container_, other.container_);
    std::swap(it_, other.it_);
    std::swap(distance_, other.distance_);
    rebase();
    other.rebase();
  }
 
 
  ref_iterator& operator++() LIEF_LIFETIMEBOUND {
    it_ = std::next(it_);
    distance_++;
    return *this;
  }
 
  ref_iterator operator++(int) {
    ref_iterator retval = *this;
    ++(*this);
    return retval;
  }
 
  ref_iterator& operator--() LIEF_LIFETIMEBOUND {
    if (it_ != std::begin(*container_.get())) {
      it_ = std::prev(it_);
      distance_--;
    }
    return *this;
  }
 
  ref_iterator operator--(int) {
    ref_iterator retval = *this;
    --(*this);
    return retval;
  }
 
 
  ref_iterator& operator+=(
      const typename ref_iterator::difference_type& movement
  ) LIEF_LIFETIMEBOUND {
    std::advance(it_, movement);
    distance_ += movement;
    return *this;
  }
 
 
  ref_iterator& operator-=(
      const typename ref_iterator::difference_type& movement
  ) LIEF_LIFETIMEBOUND {
    return (*this) += -movement;
  }
 
 
  std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>>
      operator[](size_t n) {
    return const_cast<remove_const_t<ref_t>>(
        static_cast<const ref_iterator*>(this)->operator[](n)
    );
  }
 
 
  add_const_t<ref_t> operator[](size_t n) const {
    assert(n < size() && "integrity error: out of bound");
    return details::deref<ref_t, DT_VAL>(std::next(std::begin(*container_.get()),
                                                   difference_type(n)));
  }
 
  ref_iterator operator+(typename ref_iterator::difference_type n) const {
    ref_iterator tmp = *this;
    return tmp += n;
  }
 
 
  ref_iterator operator-(typename ref_iterator::difference_type n) const {
    ref_iterator tmp = *this;
    return tmp -= n;
  }
 
 
  typename ref_iterator::difference_type operator-(const ref_iterator& rhs) const {
    return distance_ - rhs.distance_;
  }
 
  bool operator<(const ref_iterator& rhs) const {
    return (rhs - *this) > 0;
  }
 
 
  bool operator>(const ref_iterator& rhs) const {
    return rhs < *this;
  }
 
 
  bool operator>=(const ref_iterator& rhs) const {
    return !(*this < rhs);
  }
 
 
  bool operator<=(const ref_iterator& rhs) const {
    return !(*this > rhs);
  }
 
  ref_iterator begin() const {
    if (container_.get() == nullptr) {
      return {};
    }
    return ref_iterator{*container_.get()};
  }
 
  ref_iterator cbegin() const {
    return begin();
  }
 
  ref_iterator end() const {
    ref_iterator it = begin();
    if (auto* container = it.container_.get(); container != nullptr) {
      it.it_ = std::end(*container);
      it.distance_ = difference_type(container->size());
    }
    return it;
  }
 
  ref_iterator cend() const {
    return end();
  }
 
  bool is_end() const {
    return distance_ == difference_type(size());
  }
 
  bool operator==(const ref_iterator& other) const {
    // If the current iterator borrows the container we assert the equality
    // on the **address** of the container.
    if constexpr (std::is_reference_v<T>) {
      return container_.get() == other.container_.get() &&
             distance_ == other.distance_;
    } else {
      return size() == other.size() && distance_ == other.distance_;
    }
  }
 
  bool operator!=(const ref_iterator& other) const {
    return !(*this == other);
  }
 
  size_t size() const {
    const auto* container = container_.get();
    return container != nullptr ? container->size() : 0;
  }
 
  bool empty() const {
    const auto* container = container_.get();
    return container == nullptr || container->empty();
  }
 
  std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>> operator*() {
    return const_cast<remove_const_t<ref_t>>(
        static_cast<const ref_iterator*>(this)->operator*()
    );
  }
 
  add_const_t<ref_t> operator*() const {
    return details::deref<ref_t, DT_VAL>(it_);
  }
 
  std::enable_if_t<!std::is_const_v<pointer_t>, pointer_t> operator->() {
    return const_cast<remove_const_t<pointer_t>>(
        static_cast<const ref_iterator*>(this)->operator->()
    );
  }
 
  add_const_t<pointer_t> operator->() const {
    return const_cast<add_const_t<pointer_t>>(&(operator*()));
  }
 
  protected:
  // If the container is owned by this iterator, make `it_` point in this
  // container and not in the one it has been copied from
  void rebase() {
    if constexpr (!std::is_reference_v<T>) {
      it_ = std::next(std::begin(*container_.get()), distance_);
    }
  }
 
  details::container_storage<T> container_;
  ITERATOR_T it_{};
  typename ref_iterator::difference_type distance_{};
};
 

template<class T, typename U = typename decay_t<T>::value_type,
         class CT = std::add_const_t<T>>
using const_ref_iterator =
    ref_iterator<CT, U, typename decay_t<CT>::const_iterator>;
 

template<class T, typename U = typename decay_t<T>::value_type,
         class ITERATOR_T = typename decay_t<T>::iterator>
class filter_iterator {
 
  public:
  using iterator_category = std::forward_iterator_tag;
  using iterator_concept =
      details::iterator_concept_t<T, U, std::forward_iterator_tag>;
  using value_type = std::remove_cv_t<std::remove_pointer_t<decay_t<U>>>;
  using difference_type = ptrdiff_t;
  using pointer = std::remove_pointer_t<U>*;
  using reference = std::remove_pointer_t<U>&;
 
  using container_type = T;
  using DT_VAL = U;
  using DT = decay_t<T>;
  using ref_t = typename filter_iterator::reference;
  using pointer_t = typename filter_iterator::pointer;
  using filter_t = std::function<bool(const typename DT::value_type&)>;

  filter_iterator() = default;
 
  filter_iterator(const filter_iterator& other) :
    size_c_{other.size_c_},
    size_cached_{other.size_cached_},
    container_{other.container_},
    it_{other.it_},
    filters_{other.filters_},
    distance_{other.distance_} {
    rebase();
  }
 
  filter_iterator(filter_iterator&& other) noexcept :
    size_c_{other.size_c_},
    size_cached_{other.size_cached_},
    container_{std::move(other.container_)},
    it_{other.it_},
    filters_{std::move(other.filters_)},
    distance_{other.distance_} {
    rebase();
    other.size_c_ = 0;
    other.size_cached_ = false;
    other.container_ = {};
    other.it_ = {};
    other.distance_ = 0;
  }
 
  filter_iterator& operator=(const filter_iterator& other) LIEF_LIFETIMEBOUND {
    filter_iterator copy{other};
    swap(copy);
    return *this;
  }
 
  filter_iterator& operator=(filter_iterator&& other) noexcept LIEF_LIFETIMEBOUND {
    swap(other);
    return *this;
  }
 
  ~filter_iterator() = default;
 
  // NOLINTNEXTLINE(performance-unnecessary-value-param)
  filter_iterator(details::container_arg_t<T> container, filter_t filter) :
    container_{std::forward<details::container_arg_t<T>>(container)},
    it_(std::begin(*container_.get())),
    filters_{} {
    filters_.push_back(std::move(filter));
 
    if (it_ != std::end(*container_.get()) && !match()) {
      next();
    }
  }
 
  // NOLINTNEXTLINE(performance-unnecessary-value-param)
  filter_iterator(details::container_arg_t<T> container,
                  const std::vector<filter_t>& filters) :
    container_{std::forward<details::container_arg_t<T>>(container)},
    it_(std::begin(*container_.get())),
    filters_{filters} {
    if (it_ != std::end(*container_.get()) && !match()) {
      next();
    }
  }
 
  // NOLINTNEXTLINE(performance-unnecessary-value-param)
  filter_iterator(details::container_arg_t<T> container) :
    container_{std::forward<details::container_arg_t<T>>(container)},
    it_(std::begin(*container_.get())),
    filters_{} {}
 
  void swap(filter_iterator& other) noexcept {
    std::swap(container_, other.container_);
    std::swap(it_, other.it_);
    std::swap(filters_, other.filters_);
    std::swap(size_c_, other.size_c_);
    std::swap(size_cached_, other.size_cached_);
    std::swap(distance_, other.distance_);
    rebase();
    other.rebase();
  }
 
 
  filter_iterator& def(filter_t func) LIEF_LIFETIMEBOUND {
    filters_.push_back(func);
    size_c_ = 0;
    size_cached_ = false;
    return *this;
  }
 
  filter_iterator& operator++() LIEF_LIFETIMEBOUND {
    next();
    return *this;
  }
 
  filter_iterator operator++(int) {
    filter_iterator retval = *this;
    ++(*this);
    return retval;
  }
 
  filter_iterator begin() const {
    if (container_.get() == nullptr) {
      return {};
    }
    return {*container_.get(), filters_};
  }
 
  filter_iterator cbegin() const {
    return begin();
  }
 
  filter_iterator end() const {
    if (container_.get() == nullptr) {
      return {};
    }
 
    // we don't need filter for the end iterator
    filter_iterator it_end{*container_.get()};
 
    it_end.it_ = std::end(*it_end.container_.get());
    it_end.distance_ = difference_type(it_end.container_size());
 
    return it_end;
  }
 
  filter_iterator cend() const {
    return end();
  }
 
  bool is_end() const {
    return distance_ == difference_type(container_size());
  }
 
  std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>> operator*() {
    return const_cast<remove_const_t<ref_t>>(
        static_cast<const filter_iterator*>(this)->operator*()
    );
  }
 
  add_const_t<ref_t> operator*() const {
    return details::deref<ref_t, DT_VAL>(it_);
  }
 
 
  std::enable_if_t<!std::is_const_v<ref_t>, remove_const_t<ref_t>>
      operator[](size_t n) {
    return const_cast<remove_const_t<ref_t>>(
        static_cast<const filter_iterator*>(this)->operator[](n)
    );
  }
 
  add_const_t<ref_t> operator[](size_t n) const {
    assert(n < size() && "integrity error: out of bound");
 
    auto it = begin();
    std::advance(it, n);
 
    return details::deref<ref_t, DT_VAL>(std::next(std::begin(*container_.get()),
                                                   it.distance_));
  }
 
 
  std::enable_if_t<!std::is_const_v<pointer_t>, pointer_t> operator->() {
    return const_cast<remove_const_t<pointer_t>>(
        static_cast<const filter_iterator*>(this)->operator->()
    );
  }
 
  add_const_t<pointer_t> operator->() const {
    return const_cast<add_const_t<pointer_t>>(&(operator*()));
  }
 
  size_t size() const {
    if (filters_.empty()) {
      return container_size();
    }
 
    if (size_cached_) {
      return size_c_;
    }
    filter_iterator it = begin();
    size_t size = 0;
 
    auto end_iter = it.end();
    for (; it != end_iter; ++it) {
      ++size;
    }
    size_c_ = size;
    size_cached_ = true;
    return size_c_;
  }
 
 
  bool empty() const {
    if (filters_.empty()) {
      return container_size() == 0;
    }
 
    if (size_cached_) {
      return size_c_ == 0;
    }
 
    return begin() == end();
  }
 
 
  bool operator==(const filter_iterator& other) const {
    if constexpr (std::is_reference_v<T>) {
      return container_.get() == other.container_.get() &&
             distance_ == other.distance_;
    } else {
      return container_size() == other.container_size() &&
             distance_ == other.distance_;
    }
  }
 
  bool operator!=(const filter_iterator& other) const {
    return !(*this == other);
  }
 
  protected:
  size_t container_size() const {
    const auto* container = container_.get();
    return container != nullptr ? container->size() : 0;
  }
 
  bool match() const {
    return std::all_of(std::begin(filters_), std::end(filters_),
                       [this](const filter_t& f) { return f(*it_); });
  }
 
  void next() {
    if (it_ == std::end(*container_.get())) {
      distance_ = difference_type(container_size());
      return;
    }
 
    do {
      it_ = std::next(it_);
      distance_++;
    } while (it_ != std::end(*container_.get()) && !match());
  }
 
  void rebase() {
    if constexpr (!std::is_reference_v<T>) {
      it_ = std::next(std::begin(*container_.get()), distance_);
    }
  }
 
 
  mutable size_t size_c_ = 0;
  mutable bool size_cached_ = false;
  details::container_storage<T> container_;
  ITERATOR_T it_{};
  std::vector<filter_t> filters_;
  typename filter_iterator::difference_type distance_ = 0;
};

template<class T, typename U = typename decay_t<T>::value_type,
         class CT = std::add_const_t<T>>
using const_filter_iterator =
    filter_iterator<CT, U, typename decay_t<CT>::const_iterator>;
 
// ----------------------------------------------------------------------------
// This part is taken from LLVM
// ----------------------------------------------------------------------------
 
template<typename IteratorT>
class iterator_range {
  public:
  using IteratorTy = IteratorT;
  using IteratorDecayTy = std::decay_t<IteratorT>;
 
  template<class T>
  iterator_range(T&& it_begin, T&& it_end) :
    begin_(std::forward<T>(it_begin)),
    end_(std::forward<T>(it_end)) {}
 
  IteratorT begin() const {
    return begin_;
  }
  IteratorT end() const {
    return end_;
  }
  bool empty() const {
    return begin_ == end_;
  }
 
  class ReferenceProxy {
    friend iterator_range;
 
    IteratorDecayTy it_;
 
    explicit ReferenceProxy(IteratorDecayTy it) :
      it_(std::move(it)) {}
 
    public:
    using reference = decltype(*std::declval<const IteratorDecayTy&>());
 
    operator reference() const {
      return *it_;
    }
 
    template<class It = IteratorDecayTy>
    auto operator->() const -> decltype(&*std::declval<const It&>()) {
      return &*it_;
    }
  };
 
  ReferenceProxy at(typename IteratorDecayTy::difference_type pos) const {
    static_assert(IsRandomAccess, "at() needs random access iterator");
    auto it = begin_;
    std::advance(it, pos);
    return ReferenceProxy(std::move(it));
  }
 
  ReferenceProxy operator[](typename IteratorDecayTy::difference_type pos) const {
    return at(pos);
  }
 
  std::ptrdiff_t size() const {
    return std::distance(begin_, end_);
  }
 
  protected:
  static constexpr bool IsRandomAccess =
      std::is_base_of_v<std::random_access_iterator_tag,
                        typename IteratorDecayTy::iterator_category>;
  static constexpr bool IsBidirectional =
      std::is_base_of_v<std::bidirectional_iterator_tag,
                        typename IteratorDecayTy::iterator_category>;
 
  private:
  IteratorT begin_;
  IteratorT end_;
};
 
template<class T>
iterator_range<T> make_range(T&& x, T&& y) {
  return iterator_range<T>(std::forward<T>(x), std::forward<T>(y));
}
 
}
 
#if LIEF_HAS_STD_RANGES
template<typename IteratorT>
inline constexpr bool
    std::ranges::enable_borrowed_range<LIEF::iterator_range<IteratorT>> = true;
 
// A {ref,filter}_iterator that borrows its container is cheap to
// copy and can be used as a view.
 
template<class T, typename U, class IT>
inline constexpr bool std::ranges::enable_view<LIEF::ref_iterator<T, U, IT>> =
    std::is_reference_v<T>;
 
template<class T, typename U, class IT>
inline constexpr bool std::ranges::enable_view<LIEF::filter_iterator<T, U, IT>> =
    std::is_reference_v<T>;
 
// The references returned by the iterators of a borrowed range must outlive
// the range.
 
template<class T, typename U, class IT>
inline constexpr bool
    std::ranges::enable_borrowed_range<LIEF::ref_iterator<T, U, IT>> =
        std::is_reference_v<T> || std::is_pointer_v<U>;
 
template<class T, typename U, class IT>
inline constexpr bool
    std::ranges::enable_borrowed_range<LIEF::filter_iterator<T, U, IT>> =
        std::is_reference_v<T> || std::is_pointer_v<U>;
#endif
 
namespace LIEF {
 

template<typename DerivedT, typename IteratorCategoryT, typename T,
         typename DifferenceTypeT = std::ptrdiff_t, typename PointerT = T*,
         typename ReferenceT = T&>
class iterator_facade_base {
  friend DerivedT;
  iterator_facade_base() = default;
 
  public:
  using iterator_category = IteratorCategoryT;
  using value_type = T;
  using difference_type = DifferenceTypeT;
  using pointer = PointerT;
  using reference = ReferenceT;
 
  protected:
  static constexpr bool IsRandomAccess =
      std::is_base_of_v<std::random_access_iterator_tag, IteratorCategoryT>;
  static constexpr bool IsBidirectional =
      std::is_base_of_v<std::bidirectional_iterator_tag, IteratorCategoryT>;

  class ReferenceProxy {
    friend iterator_facade_base;
 
    DerivedT I;
 
    ReferenceProxy(DerivedT I) :
      I(std::move(I)) {}
 
    public:
    operator ReferenceT() const {
      return *I;
    }
  };

  class PointerProxy {
    friend iterator_facade_base;
 
    ReferenceT R;
 
    template<typename RefT>
    PointerProxy(RefT&& R) : // NOLINT(bugprone-forwarding-reference-overload)
      R(std::forward<RefT>(R)) {}
 
    public:
    PointerT operator->() const {
      return &R;
    }
  };
 
  public:
  DerivedT operator+(DifferenceTypeT n) const {
    static_assert(std::is_base_of_v<iterator_facade_base, DerivedT>,
                  "Must pass the derived type to this template!");
    static_assert(IsRandomAccess,
                  "The '+' operator is only defined for random access iterators.");
    DerivedT tmp = *static_cast<const DerivedT*>(this);
    tmp += n;
    return tmp;
  }
  friend DerivedT operator+(DifferenceTypeT n, const DerivedT& i) {
    static_assert(IsRandomAccess,
                  "The '+' operator is only defined for random access iterators.");
    return i + n;
  }
  DerivedT operator-(DifferenceTypeT n) const {
    static_assert(IsRandomAccess,
                  "The '-' operator is only defined for random access iterators.");
    DerivedT tmp = *static_cast<const DerivedT*>(this);
    tmp -= n;
    return tmp;
  }
 
  DerivedT& operator++() {
    static_assert(std::is_base_of_v<iterator_facade_base, DerivedT>,
                  "Must pass the derived type to this template!");
    return static_cast<DerivedT*>(this)->operator+=(1);
  }
  DerivedT operator++(int) {
    DerivedT tmp = *static_cast<DerivedT*>(this);
    ++*static_cast<DerivedT*>(this);
    return tmp;
  }
  DerivedT& operator--() {
    static_assert(
        IsBidirectional,
        "The decrement operator is only defined for bidirectional iterators."
    );
    return static_cast<DerivedT*>(this)->operator-=(1);
  }
  DerivedT operator--(int) {
    static_assert(
        IsBidirectional,
        "The decrement operator is only defined for bidirectional iterators."
    );
    DerivedT tmp = *static_cast<DerivedT*>(this);
    --*static_cast<DerivedT*>(this);
    return tmp;
  }
 
#ifndef __cpp_impl_three_way_comparison
  bool operator!=(const DerivedT& RHS) const {
    return !(static_cast<const DerivedT&>(*this) == RHS);
  }
#endif
 
  bool operator>(const DerivedT& RHS) const {
    static_assert(
        IsRandomAccess,
        "Relational operators are only defined for random access iterators."
    );
    return !(static_cast<const DerivedT&>(*this) < RHS) &&
           !(static_cast<const DerivedT&>(*this) == RHS);
  }
  bool operator<=(const DerivedT& RHS) const {
    static_assert(
        IsRandomAccess,
        "Relational operators are only defined for random access iterators."
    );
    return !(static_cast<const DerivedT&>(*this) > RHS);
  }
  bool operator>=(const DerivedT& RHS) const {
    static_assert(
        IsRandomAccess,
        "Relational operators are only defined for random access iterators."
    );
    return !(static_cast<const DerivedT&>(*this) < RHS);
  }
 
  PointerProxy operator->() const {
    return static_cast<const DerivedT*>(this)->operator*();
  }
  ReferenceProxy operator[](DifferenceTypeT n) const {
    static_assert(IsRandomAccess,
                  "Subscripting is only defined for random access iterators.");
    return static_cast<const DerivedT*>(this)->operator+(n);
  }
};

template<typename DerivedT, typename WrappedIteratorT,
         typename IteratorCategoryT =
             typename std::iterator_traits<WrappedIteratorT>::iterator_category,
         typename T = typename std::iterator_traits<WrappedIteratorT>::value_type,
         typename DifferenceTypeT =
             typename std::iterator_traits<WrappedIteratorT>::difference_type,
         typename PointerT = std::conditional_t<
             std::is_same_v<T, typename std::iterator_traits<WrappedIteratorT>::
                                   value_type>,
             typename std::iterator_traits<WrappedIteratorT>::pointer, T*
         >,
         typename ReferenceT = std::conditional_t<
             std::is_same_v<T, typename std::iterator_traits<WrappedIteratorT>::
                                   value_type>,
             typename std::iterator_traits<WrappedIteratorT>::reference, T&
         >>
class iterator_adaptor_base
  : public iterator_facade_base<DerivedT, IteratorCategoryT, T, DifferenceTypeT,
                                PointerT, ReferenceT> {
  using BaseT = typename iterator_adaptor_base::iterator_facade_base;
 
  protected:
  WrappedIteratorT I;
 
  iterator_adaptor_base() = default;
 
  explicit iterator_adaptor_base(WrappedIteratorT u) :
    I(std::move(u)) {
    static_assert(std::is_base_of_v<iterator_adaptor_base, DerivedT>,
                  "Must pass the derived type to this template!");
  }
 
  const WrappedIteratorT& wrapped() const {
    return I;
  }
 
  public:
  using difference_type = DifferenceTypeT;
 
  DerivedT& operator+=(difference_type n) {
    static_assert(
        BaseT::IsRandomAccess,
        "The '+=' operator is only defined for random access iterators."
    );
    I += n;
    return *static_cast<DerivedT*>(this);
  }
  DerivedT& operator-=(difference_type n) {
    static_assert(
        BaseT::IsRandomAccess,
        "The '-=' operator is only defined for random access iterators."
    );
    I -= n;
    return *static_cast<DerivedT*>(this);
  }
  using BaseT::operator-;
  difference_type operator-(const DerivedT& RHS) const {
    static_assert(BaseT::IsRandomAccess,
                  "The '-' operator is only defined for random access iterators.");
    return I - RHS.I;
  }
 
  // We have to explicitly provide ++ and -- rather than letting the facade
  // forward to += because WrappedIteratorT might not support +=.
  using BaseT::operator++;
  DerivedT& operator++() LIEF_LIFETIMEBOUND {
    ++I;
    return *static_cast<DerivedT*>(this);
  }
  using BaseT::operator--;
  DerivedT& operator--() LIEF_LIFETIMEBOUND {
    static_assert(
        BaseT::IsBidirectional,
        "The decrement operator is only defined for bidirectional iterators."
    );
    --I;
    return *static_cast<DerivedT*>(this);
  }
 
  friend bool operator==(const iterator_adaptor_base& LHS,
                         const iterator_adaptor_base& RHS) {
    return LHS.I == RHS.I;
  }
  friend bool operator<(const iterator_adaptor_base& LHS,
                        const iterator_adaptor_base& RHS) {
    static_assert(
        BaseT::IsRandomAccess,
        "Relational operators are only defined for random access iterators."
    );
    return LHS.I < RHS.I;
  }
 
  ReferenceT operator*() const {
    return *I;
  }
};

template<typename WrappedIteratorT,
         typename T =
             std::remove_reference_t<decltype(**std::declval<WrappedIteratorT>())>>
struct pointee_iterator
  : iterator_adaptor_base<
        pointee_iterator<WrappedIteratorT, T>, WrappedIteratorT,
        typename std::iterator_traits<WrappedIteratorT>::iterator_category, T
    > {
  pointee_iterator() = default;
  template<typename U>
  pointee_iterator(U&& u) : // NOLINT(bugprone-forwarding-reference-overload)
    pointee_iterator::iterator_adaptor_base(std::forward<U>(u)) {}
 
  T& operator*() const {
    return **this->I;
  }
};
 
template<typename RangeT,
         typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iterator_range<pointee_iterator<WrappedIteratorT>>
    make_pointee_range(RangeT&& Range) {
  using PointeeIteratorT = pointee_iterator<WrappedIteratorT>;
  return make_range(PointeeIteratorT(std::begin(std::forward<RangeT>(Range))),
                    PointeeIteratorT(std::end(std::forward<RangeT>(Range))));
}
 
template<typename WrappedIteratorT,
         typename T = decltype(&*std::declval<WrappedIteratorT>())>
class pointer_iterator
  : public iterator_adaptor_base<
        pointer_iterator<WrappedIteratorT, T>, WrappedIteratorT,
        typename std::iterator_traits<WrappedIteratorT>::iterator_category, T
    > {
  mutable T Ptr;
 
  public:
  pointer_iterator() = default;
 
  explicit pointer_iterator(WrappedIteratorT u) :
    pointer_iterator::iterator_adaptor_base(std::move(u)) {}
 
  T& operator*() const {
    return Ptr = &*this->I;
  }
};
 
template<typename RangeT,
         typename WrappedIteratorT = decltype(std::begin(std::declval<RangeT>()))>
iterator_range<pointer_iterator<WrappedIteratorT>>
    make_pointer_range(RangeT&& Range) {
  using PointerIteratorT = pointer_iterator<WrappedIteratorT>;
  return make_range(PointerIteratorT(std::begin(std::forward<RangeT>(Range))),
                    PointerIteratorT(std::end(std::forward<RangeT>(Range))));
}
 
template<typename WrappedIteratorT,
         typename T1 =
             std::remove_reference_t<decltype(**std::declval<WrappedIteratorT>())>,
         typename T2 = std::add_pointer_t<T1>>
using raw_pointer_iterator =
    pointer_iterator<pointee_iterator<WrappedIteratorT, T1>, T2>;
}
 
#endif