transform.hpp

Go to the documentation of this file.

/* This file is part of OpenKalman, a header-only C++ library for
 * Kalman filters and other recursive filters.
 *
 * Copyright (c) 2025 Christopher Lee Ogden <ogden@gatech.edu>
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#ifndef OPENKALMAN_COMPATIBILITY_VIEWS_TRANSFORM_HPP
#define OPENKALMAN_COMPATIBILITY_VIEWS_TRANSFORM_HPP

#include "basics/compatibility/language-features.hpp"
#include "basics/compatibility/invoke.hpp"
#include "basics/compatibility/internal/movable_box.hpp"
#include "view-concepts.hpp"
#include "view_interface.hpp"
#include "all.hpp"

namespace OpenKalman::stdex::ranges
{
#ifdef __cpp_lib_ranges
  using std::ranges::transform_view;
  namespace views
  {
    using std::ranges::views::transform;
  }
#else

  template<typename V, typename F>
  struct transform_view : stdex::ranges::view_interface<transform_view<V, F>>
  {
  private:

    static_assert(stdex::ranges::input_range<V>);
    static_assert(std::is_move_constructible_v<F>);
    static_assert(stdex::ranges::view<V>);
    static_assert(std::is_object_v<F>);
    static_assert(std::is_invocable_v<F&, stdex::ranges::range_reference_t<V>>);

    template<bool Const, typename T>
    using maybe_const = std::conditional_t<Const, const T, T>;

  public:

    template<bool> struct sentinel;


    template<bool Const>
    struct iterator
    {
    private:

      using Parent = maybe_const<Const, transform_view>;
      using Base = maybe_const<Const, V>;
      using MCF = maybe_const<Const, F>;

    public:

      using iterator_concept = std::conditional_t<
        stdex::ranges::random_access_range<Base>, std::random_access_iterator_tag,
        std::conditional_t<stdex::ranges::bidirectional_range<Base>, std::bidirectional_iterator_tag,
        std::conditional_t<stdex::ranges::forward_range<Base>, std::forward_iterator_tag, std::input_iterator_tag>>>;

      using iterator_category = std::conditional_t<
        not std::is_reference_v<std::invoke_result_t<MCF&, stdex::ranges::range_reference_t<Base>>>,
        std::input_iterator_tag,
        typename stdex::iterator_traits<stdex::ranges::iterator_t<Base>>::iterator_category>;

      using reference = std::invoke_result_t<MCF&, stdex::ranges::range_reference_t<Base>>;
      using value_type = stdex::remove_cvref_t<std::invoke_result_t<MCF&, stdex::ranges::range_reference_t<Base>>>;
      using difference_type = stdex::ranges::range_difference_t<Base>;
      using pointer = void;

      template<bool Enable = true, std::enable_if_t<Enable and stdex::default_initializable<stdex::ranges::iterator_t<Base>>, int> = 0>
      constexpr iterator() {};

      constexpr iterator(Parent& parent, stdex::ranges::iterator_t<Base> current) : current_ {std::move(current)}, parent_ {std::addressof(parent)} {}

      template<bool Enable = Const, std::enable_if_t<Enable and stdex::convertible_to<stdex::ranges::iterator_t<V>, stdex::ranges::iterator_t<Base>>, int> = 0>
      constexpr iterator(iterator<not Const> i) : current_ {std::move(i.current_)}, parent_ {std::move(i.parent_)} {}

      constexpr const stdex::ranges::iterator_t<Base>& base() const & noexcept { return current_; }

      constexpr stdex::ranges::iterator_t<Base> base() && { return std::move(current_); }

      constexpr decltype(auto) operator*() const
      {
        return stdex::invoke(*parent_->fun_, *current_);
      }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      constexpr decltype(auto) operator[](difference_type n) const
      {
        return stdex::invoke(*parent_->fun_, current_[n]);
      }

      constexpr iterator& operator++() { ++current_; return *this; }

      template<bool Enable = true, std::enable_if_t<Enable and not stdex::ranges::forward_range<Base>, int> = 0>
      constexpr void operator++(int) { ++current_; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::forward_range<Base>, int> = 0>
      constexpr iterator operator++(int) { auto tmp = *this; ++*this; return tmp; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::bidirectional_range<Base>, int> = 0>
      constexpr iterator& operator--() { --current_; return *this; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::bidirectional_range<Base>, int> = 0>
      constexpr iterator operator--(int) { auto tmp = *this; --*this; return tmp; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      constexpr iterator& operator+=(const difference_type& n) { current_ += n; return *this; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      constexpr iterator& operator-=(const difference_type& n) { current_ -= n; return *this; }

      friend constexpr bool operator==(const iterator& x, const iterator& y) { return x.current_ == y.current_; }

      friend constexpr bool operator!=(const iterator& x, const iterator& y) { return not (x.current_ == y.current_); }

      friend constexpr bool operator<(const iterator& x, const iterator& y) { return x.current_ < y.current_; }

      friend constexpr bool operator>(const iterator& x, const iterator& y) { return y < x; }

      friend constexpr bool operator<=(const iterator& x, const iterator& y) { return not (y < x); }

      friend constexpr bool operator>=(const iterator& x, const iterator& y) { return not (x < y); }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      friend constexpr iterator operator+(const iterator& i, const difference_type& n) { return iterator {*i.parent_, i.current_ + n}; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      friend constexpr iterator operator+(const difference_type& n, const iterator& i) { return iterator {*i.parent_, i.current_ + n}; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      friend constexpr iterator operator-(const iterator& i, const difference_type& n) { return iterator {*i.parent_, i.current_ - n}; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      friend constexpr difference_type operator-(const iterator& x, const iterator& y) { return x.current_ - y.current_; }

      template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::random_access_range<Base>, int> = 0>
      friend constexpr decltype(auto) iter_move(const iterator& i) noexcept(noexcept(stdex::invoke(*i.parent_->fun_, *i.current_)))
      {
        if constexpr (std::is_lvalue_reference_v<decltype(*i)>) return std::move(*i);
        else return *i;
      }

    private:

      template<bool> friend struct transform_view::sentinel;
      stdex::ranges::iterator_t<Base> current_;
      Parent* parent_;
    };


    template<bool Const>
    struct sentinel
    {
    private:

      using Parent = maybe_const<Const, transform_view>;
      using Base = maybe_const<Const, V>;
      using difference_type = stdex::ranges::range_difference_t<Base>;

    public:

      sentinel() = default;

      constexpr explicit sentinel(stdex::ranges::sentinel_t<Base> end) : end_ {end} {};

      constexpr const stdex::ranges::sentinel_t<Base>& base() const { return end_; }

      friend constexpr bool operator==( const iterator<Const>& x, const sentinel<Const>& y ) { return x.current_ == y.end_; }

      friend constexpr bool operator==( const sentinel<Const>& y, const iterator<Const>& x ) { return y.end_ == x.current_; }

      friend constexpr bool operator!=( const iterator<Const>& x, const sentinel<Const>& y ) { return not (x.current_ == y.end_); }

      friend constexpr bool operator!=( const sentinel<Const>& y, const iterator<Const>& x ) { return not (y.end_ == x.current_); }

      template<bool Enable = true, std::enable_if_t<Enable and
        stdex::convertible_to<decltype(std::declval<stdex::ranges::iterator_t<Base>>() - std::declval<stdex::ranges::sentinel_t<Base>>()), difference_type>, int> = 0>
      friend constexpr difference_type operator-(const iterator<Const>& x, const sentinel& y)
      { return x.current_ - y.end_; }

      template<bool Enable = true, std::enable_if_t<Enable and
        stdex::convertible_to<decltype(-(std::declval<stdex::ranges::sentinel_t<Base>>() - std::declval<stdex::ranges::iterator_t<Base>>())), difference_type>, int> = 0>
      friend constexpr difference_type operator-(const sentinel& y, const iterator<Const>& x)
      { return y.end_ - x.current_; }

    private:

      stdex::ranges::sentinel_t<Base> end_;
    };


    template<bool Enable = true, std::enable_if_t<Enable and stdex::default_initializable<V> and stdex::default_initializable<F>, int> = 0>
    constexpr
    transform_view() {}


    constexpr explicit
    transform_view(V base, F fun) : base_ {std::move(base)}, fun_ {std::move(fun)} {}


    template<bool Enable = true, std::enable_if_t<Enable and stdex::copy_constructible<V>, int> = 0>
    constexpr V
    base() const& { return base_; }

    constexpr V
    base() && { return std::move(base_); }


    constexpr auto
    begin() { return iterator<false> {*this, stdex::ranges::begin(base_)}; }

    template<bool Enable = true, std::enable_if_t<Enable and
      stdex::ranges::range<const V> and std::is_invocable_v<const F&, stdex::ranges::range_reference_t<const V>>, int> = 0>
    constexpr auto
    begin() const { return iterator<true> {*this, stdex::ranges::begin(base_)}; }


    template<bool Enable = true, std::enable_if_t<Enable and not stdex::ranges::common_range<V>, int> = 0>
    constexpr auto
    end() { return sentinel<false> {stdex::ranges::end(base_)}; }

    template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::common_range<V>, int> = 0>
    constexpr auto
    end() { return iterator<false> {*this, stdex::ranges::end(base_)}; }

    template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::range<const V> and not stdex::ranges::common_range<const V> and
      std::is_invocable_v<const F&, stdex::ranges::range_reference_t<const V>>, int> = 0>
    constexpr auto
    end() const { return sentinel<true> {stdex::ranges::end(base_)}; }

    template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::common_range<const V> and
      std::is_invocable_v<const F&, stdex::ranges::range_reference_t<const V>>, int> = 0>
    constexpr auto
    end() const { return iterator<true> {*this, stdex::ranges::end(base_)}; }


    template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::sized_range<V>, int> = 0>
    constexpr auto
    size() { return stdex::ranges::size(base_); }

    template<bool Enable = true, std::enable_if_t<Enable and stdex::ranges::sized_range<const V>, int> = 0>
    constexpr auto
    size() const { return stdex::ranges::size(base_); }

  private:

    V base_;
    OpenKalman::internal::movable_box<F> fun_;

  };


  template<typename R, typename F>
  transform_view(R&&, F) -> transform_view<views::all_t<R>, F>;


  namespace views
  {
    namespace detail
    {
      template<typename F>
      struct transform_closure
        : stdex::ranges::range_adaptor_closure<transform_closure<F>>
      {
        constexpr transform_closure(F&& f) : my_f {std::forward<F>(f)} {};

        template<typename R, std::enable_if_t<stdex::ranges::viewable_range<R>, int> = 0>
        constexpr auto
        operator() (R&& r) const { return transform_view {std::forward<R>(r), my_f}; }

      private:
        F my_f;
      };


      struct transform_adaptor
      {
        template<typename F>
        constexpr auto
        operator() (F&& f) const
        {
          return transform_closure<F> {std::forward<F>(f)};
        }


        template<typename R, typename F, std::enable_if_t<stdex::ranges::viewable_range<R>, int> = 0>
        constexpr auto
        operator() (R&& r, F&& f) const
        {
          return transform_view {std::forward<R>(r), std::forward<F>(f)};
        }

      };

    }


    inline constexpr detail::transform_adaptor transform;

  }

#endif
}

#endif