transform.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_TRANSFORM_HPP
#define _ITERTOOLS_TRANSFORM_HPP
 
#include "./iterator_facade.hpp"
#include "./sentinel.hpp"
 
#include <iterator>
#include <optional>
#include <type_traits>
#include <utility>
 
namespace itertools {
 
  template <typename Iter, typename F, typename Value = std::invoke_result_t<F, typename std::iterator_traits<Iter>::value_type>>
  struct transform_iter : iterator_facade<transform_iter<Iter, F>, Value> {
    Iter it;
 
    mutable std::optional<F> lambda;
 
    transform_iter() = default;
 
    transform_iter(Iter it, F lambda) : it(std::move(it)), lambda(std::move(lambda)) {}
 
    void increment() { ++it; }
 
    transform_iter(transform_iter &&) = default;
 
    transform_iter(transform_iter const &) = default;
 
    transform_iter &operator=(transform_iter &&) = default;
 
    transform_iter &operator=(transform_iter const &other) {
      it = other.it;
      if (other.lambda.has_value())
        lambda.emplace(other.lambda.value());
      else
        lambda.reset();
      return *this;
    }
 
    [[nodiscard]] bool operator==(transform_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 (*lambda)(*it); }
  };
 
  template <typename R, typename F> struct transformed {
    R rg;
 
    F lambda;
 
    using const_iterator = transform_iter<decltype(std::cbegin(rg)), F>;
 
    using iterator = const_iterator;
 
    [[nodiscard]] const_iterator cbegin() const noexcept { return {std::cbegin(rg), lambda}; }
 
    [[nodiscard]] const_iterator begin() const noexcept { return cbegin(); }
 
    [[nodiscard]] auto cend() const noexcept { return make_sentinel(std::cend(rg)); }
 
    [[nodiscard]] auto end() const noexcept { return cend(); }
  };
 
  template <typename R, typename F> [[nodiscard]] auto transform(R &&rg, F lambda) {
    return transformed<R, F>{std::forward<R>(rg), std::move(lambda)};
  }
 
} // namespace itertools
 
#endif // _ITERTOOLS_TRANSFORM_HPP