iterator_facade.hpp

Go to the documentation of this file.

// Copyright (c) 2024 Simons Foundation
//
// 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.txt
//
// 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.
//
// Authors: Thomas Hahn, Olivier Parcollet, Nils Wentzell, chuffa
 
#ifndef _ITERTOOLS_ITERATOR_FACADE_HPP
#define _ITERTOOLS_ITERATOR_FACADE_HPP
 
#include <cstddef>
#include <iterator>
 
namespace itertools {
 
  // Forward declaration.
  template <typename Iter, typename Value, typename Tag = std::forward_iterator_tag, typename Reference = Value &,
            typename Difference = std::ptrdiff_t>
  struct iterator_facade;
 
  template <typename Iter, typename Value, typename Reference, typename Difference>
  struct iterator_facade<Iter, Value, std::forward_iterator_tag, Reference, Difference> {
    private:
    // Get a reference to the derived iterator.
    [[nodiscard]] Iter &self() { return static_cast<Iter &>(*this); }
 
    // Get a const reference to the derived iterator.
    [[nodiscard]] Iter const &self() const { return static_cast<const Iter &>(*this); }
 
    public:
    using value_type = Value;
 
    using reference = Reference;
 
    using pointer = Value *;
 
    using difference_type = Difference;
 
    using iterator_category = std::forward_iterator_tag;
 
    Iter &operator++() {
      self().increment();
      return self();
    }
 
    Iter operator++(int) {
      Iter c = self();
      self().increment();
      return c;
    }
 
    [[nodiscard]] decltype(auto) operator*() const { return self().dereference(); }
 
    [[nodiscard]] decltype(auto) operator->() const { return operator*(); }
  };
 
} // namespace itertools
 
#endif // _ITERTOOLS_ITERATOR_FACADE_HPP