[feature] add radr::all for compatibility

Author: h-2

include/radr/rad/all.hpp

@@ -0,0 +1,54 @@
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Copyright (c) 2023-2025 Hannes Hauswedell
+//
+// Licensed under the Apache License v2.0 with LLVM Exceptions.
+// See the LICENSE file for details.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "radr/custom/subborrow.hpp"
+#include "radr/detail/pipe.hpp"
+#include "radr/rad/to_single_pass.hpp"
+
+namespace radr
+{
+
+inline namespace cpo
+{
+/*!\brief A NOOP range adaptor provided for compatibility.
+ * \param urange The underlying range.
+ *
+ * This range adaptor is semantically a NOOP, i.e. the returned range has the same elements
+ * and generally satisfies the same concepts. However, the actual range type will be different
+ * (and may be customised).
+ *
+ * ### Multi-pass adaptor
+ *
+ * Requirements:
+ *   * `radr::mp_range<URange>`
+ *
+ * Calls radr::borrow on \p urange which may result in a customised range type being returned.
+ *
+ * Unless customised otherwise, preserves all range concepts and is transparant (preserves iterator and
+ * sentinel types).
+ *
+ * ### Single-pass adaptor
+ *
+ * Requirements:
+ *   * `std::ranges::input_range<URange>`
+ *
+ * Returns the range as-is.
+ */
+#ifndef RADR_ALL_NO_DEPRECATED
+[[deprecated(
+  "radr::all is provided as a (mostly) NOOP adaptor. You probably want radr::borrow instead.\n"
+  "You can silence this warning by defining RADR_ALL_NO_DEPRECATED.")]]
+#endif
+inline constexpr auto all = detail::pipe_without_args_fn<decltype(detail::to_single_pass_coro), decltype(borrow)>{};
+} // namespace cpo
+} // namespace radr

tests/unit/rad/CMakeLists.txt

@@ -1,3 +1,4 @@
+radr_unit_test(all_)
 radr_unit_test(as_const)
 radr_unit_test(as_rvalue)
 radr_unit_test(to_common)

tests/unit/rad/all_.cpp

@@ -0,0 +1,133 @@
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <ranges>
+#include <span>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include <radr/test/adaptor_template.hpp>
+#include <radr/test/aux_ranges.hpp>
+#include <radr/test/gtest_helpers.hpp>
+
+#define RADR_ALL_NO_DEPRECATED 1
+#include <radr/concepts.hpp>
+#include <radr/rad/all.hpp>
+#include <radr/range_access.hpp>
+
+// --------------------------------------------------------------------------
+// test data
+// --------------------------------------------------------------------------
+
+inline std::vector<size_t> const comp{1, 2, 3, 4, 5, 6};
+
+// --------------------------------------------------------------------------
+// input test
+// --------------------------------------------------------------------------
+
+#if !defined(_GLIBCXX_RELEASE) || (_GLIBCXX_RELEASE >= 12)
+TEST(all, input)
+{
+    std::istringstream input("10 20 30 40");
+
+    auto rng = std::views::istream<int>(input) | radr::all;
+
+    EXPECT_SAME_TYPE(decltype(rng), (std::ranges::basic_istream_view<int, char>));
+}
+#endif
+
+// --------------------------------------------------------------------------
+// forward tests
+// --------------------------------------------------------------------------
+
+template <typename _container_t>
+struct all_forward : public testing::Test
+{
+    /* data members */
+    _container_t in{1, 2, 3, 4, 5, 6};
+
+    /* type foo */
+    using container_t = _container_t;
+
+    using it_t   = decltype(radr::begin(std::declval<container_t &>()));
+    using sen_t  = decltype(radr::end(std::declval<container_t &>()));
+    using cit_t  = decltype(radr::cbegin(std::declval<container_t const &>()));
+    using csen_t = decltype(radr::cend(std::declval<container_t const &>()));
+
+    static constexpr radr::borrowing_rad_kind bk =
+      std::ranges::sized_range<container_t> ? radr::borrowing_rad_kind::sized : radr::borrowing_rad_kind::unsized;
+    using borrow_t = radr::borrowing_rad<it_t, sen_t, cit_t, csen_t, bk>;
+
+    template <typename in_t>
+    static void type_checks_impl()
+    {
+        /* preserved for all all adaptors */
+        EXPECT_EQ(std::ranges::sized_range<in_t>, std::ranges::sized_range<container_t>);
+        EXPECT_EQ(std::ranges::common_range<in_t>, std::ranges::common_range<container_t>);
+        EXPECT_EQ(std::ranges::bidirectional_range<in_t>, std::ranges::bidirectional_range<container_t>);
+        EXPECT_EQ(std::ranges::random_access_range<in_t>, std::ranges::random_access_range<container_t>);
+        EXPECT_EQ(std::ranges::contiguous_range<in_t>, std::ranges::contiguous_range<container_t>);
+
+        /* valid for all all adaptors */
+        EXPECT_TRUE(radr::const_symmetric_range<in_t>);
+    }
+
+    template <typename in_t>
+    static void type_checks()
+    {
+        radr::test::generic_adaptor_checks<in_t, container_t>();
+
+        EXPECT_SAME_TYPE(radr::iterator_t<in_t>, it_t);
+        EXPECT_SAME_TYPE(radr::sentinel_t<in_t>, sen_t);
+        EXPECT_SAME_TYPE(radr::const_iterator_t<in_t>, cit_t);
+        EXPECT_SAME_TYPE(radr::const_sentinel_t<in_t>, csen_t);
+    }
+};
+
+//TODO: add non-common, add non-ref referenct_t
+using container_types = ::testing::Types<std::forward_list<size_t>, // unsized
+                                         std::list<size_t>,         // sized without sized_sentinel
+                                         std::deque<size_t>,
+                                         std::vector<size_t>>;
+
+TYPED_TEST_SUITE(all_forward, container_types);
+
+TYPED_TEST(all_forward, rvalue)
+{
+    using container_t = TestFixture::container_t;
+    using borrow_t    = TestFixture::borrow_t;
+
+    auto ra = std::move(this->in) | radr::all;
+
+    EXPECT_RANGE_EQ(ra, comp);
+    EXPECT_SAME_TYPE(decltype(ra), (radr::owning_rad<container_t, borrow_t>));
+
+    TestFixture::template type_checks<decltype(ra)>();
+}
+
+TYPED_TEST(all_forward, lvalue)
+{
+    using borrow_t = TestFixture::borrow_t;
+
+    auto ra = std::ref(this->in) | radr::all;
+
+    EXPECT_RANGE_EQ(ra, comp);
+    EXPECT_SAME_TYPE(decltype(ra), borrow_t);
+
+    TestFixture::template type_checks<decltype(ra)>();
+}
+
+// --------------------------------------------------------------------------
+// owning copy test
+// --------------------------------------------------------------------------
+
+TEST(all, owning_copy_test)
+{
+    auto own = std::vector{1, 2, 3, 4, 5, 6} | radr::all;
+    EXPECT_RANGE_EQ(own, comp);
+
+    auto cpy = own;
+    EXPECT_RANGE_EQ(own, cpy);
+}
+
+#undef RADR_ALL_NO_DEPRECATED