owning_view.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_OWNING_VIEW_HPP
#define OPENKALMAN_COMPATIBILITY_VIEWS_OWNING_VIEW_HPP

#ifndef __cpp_lib_ranges

#include "basics/compatibility/ranges.hpp"
#include "view_interface.hpp"

namespace OpenKalman::ranges
{
  template<typename R>
  struct owning_view : view_interface<owning_view<R>>
  {
    static_assert(std::is_object_v<std::remove_reference_t<R>> and std::is_move_constructible_v<std::remove_reference_t<R>> and
      std::is_assignable_v<std::remove_reference_t<R>&, std::remove_reference_t<R>> and
      not OpenKalman::internal::is_initializer_list<R>::value);


    template<typename aR = R, std::enable_if_t<std::is_default_constructible_v<aR>, int> = 0>
    constexpr
    owning_view() {}


    constexpr
    owning_view(owning_view&& other) = default;


    explicit constexpr
    owning_view(R&& t) : my_r {std::forward<R>(t)} {}


    constexpr owning_view&
    operator=(owning_view&& other) = default;


    constexpr decltype(auto)
    base() & { return my_r; }

    constexpr decltype(auto)
    base() const & { return my_r; }

    constexpr decltype(auto)
    base() && noexcept { return std::move(*this).my_r; }

    constexpr decltype(auto)
    base() const && noexcept { return std::move(*this).my_r; }


    constexpr auto begin() { return ranges::begin(my_r); }

    template<bool Enable = true, std::enable_if_t<Enable and range<const R>, int> = 0>
    constexpr auto begin() const { return ranges::begin(my_r); }


    constexpr auto end() { return ranges::end(my_r); }

    template<bool Enable = true, std::enable_if_t<Enable and range<const R>, int> = 0>
    constexpr auto end() const { return ranges::end(my_r); }


    template<typename Enable = void, typename = std::void_t<Enable, decltype(ranges::empty(std::declval<R>()))>>
    constexpr auto empty() { return ranges::empty(my_r); }

    template<typename Enable = void, typename = std::void_t<Enable, decltype(ranges::empty(std::declval<const R>()))>>
    constexpr auto empty() const { return ranges::empty(my_r); }


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

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

  private:

   R my_r;

  };


  template<typename R>
  constexpr bool enable_borrowed_range<owning_view<R>> = enable_borrowed_range<R>;

}



#endif

#endif //OPENKALMAN_COMPATIBILITY_VIEWS_OWNING_VIEW_HPP