enumerate.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_ENUMERATE_HPP
#define _ITERTOOLS_ENUMERATE_HPP
 
#include "./iterator_facade.hpp"
#include "./sentinel.hpp"
 
#include <iterator>
#include <tuple>
#include <utility>
 
namespace itertools {
 
  template <typename Iter> struct enum_iter : iterator_facade<enum_iter<Iter>, std::pair<long, typename std::iterator_traits<Iter>::value_type>> {
    Iter it;
 
    long i = 0;
 
    enum_iter() = default;
 
    enum_iter(Iter it) : it(std::move(it)) {}
 
    void increment() {
      ++it;
      ++i;
    }
 
    [[nodiscard]] bool operator==(enum_iter const &other) const { return it == other.it; }
 
    template <typename SentinelIter> [[nodiscard]] bool operator==(sentinel_t<SentinelIter> const &s) const { return it == s.it; }
 
    [[nodiscard]] decltype(auto) dereference() const { return std::tuple<long, decltype(*it)>{i, *it}; }
  };
 
  template <typename R> struct enumerated {
    R rg;
 
    using iterator = enum_iter<decltype(std::begin(rg))>;
 
    using const_iterator = enum_iter<decltype(std::cbegin(rg))>;
 
    [[nodiscard]] bool operator==(enumerated const &) const = default;
 
    [[nodiscard]] iterator begin() noexcept { return std::begin(rg); }
 
    [[nodiscard]] const_iterator cbegin() const noexcept { return std::cbegin(rg); }
 
    [[nodiscard]] const_iterator begin() const noexcept { return cbegin(); }
 
    [[nodiscard]] auto end() noexcept { return make_sentinel(std::end(rg)); }
 
    [[nodiscard]] auto cend() const noexcept { return make_sentinel(std::cend(rg)); }
 
    [[nodiscard]] auto end() const noexcept { return cend(); }
  };
 
  template <typename R> [[nodiscard]] enumerated<R> enumerate(R &&rg) { return {std::forward<R>(rg)}; }
 
} // namespace itertools
 
#endif // _ITERTOOLS_ENUMERATE_HPP