Implement ranges::uninitialized_copy

miscco · miscco · commit e1decd0121c5 · 2020-08-10T20:12:45.000+02:00
diff --git a/stl/inc/memory b/stl/inc/memory
@@ -56,6 +56,71 @@ namespace ranges {
     concept _No_throw_forward_range = _No_throw_input_range<_Rng>
         && _No_throw_forward_iterator<iterator_t<_Rng>>;
     // clang-format on
+
+    // ALIAS TEMPLATE uninitialized_copy_result
+    template <class _In, class _Out>
+    using uninitialized_copy_result = in_out_result<_In, _Out>;
+
+    // VARIABLE ranges::uninitialized_copy
+    class _Uninitialized_copy_fn : private _Not_quite_object {
+    public:
+        using _Not_quite_object::_Not_quite_object;
+
+        // clang-format off
+        template <input_iterator _It1, sentinel_for<_It1> _Se1, _No_throw_forward_iterator _It2, _No_throw_sentinel_for<_It2> _Se2>
+            requires constructible_from<iter_value_t<_It2>, iter_reference_t<_It1>>
+        uninitialized_copy_result<_It1, _It2> operator()(_It1 _First1, _Se1 _Last1, _It2 _First2, _Se2 _Last2) const {
+            // clang-format on
+            _Adl_verify_range(_First1, _Last1);
+            _Adl_verify_range(_First2, _Last2);
+            auto _UResult =
+                _Uninitialized_copy_unchecked(_Get_unwrapped(_STD move(_First1)), _Get_unwrapped(_STD move(_Last1)),
+                    _Get_unwrapped(_STD move(_First2)), _Get_unwrapped(_STD move(_Last2)));
+
+            _Seek_wrapped(_First1, _STD move(_UResult.in));
+            _Seek_wrapped(_First2, _STD move(_UResult.out));
+            return {_STD move(_First1), _STD move(_First2)};
+        }
+
+        // clang-format off
+        template <input_range _Rng1, _No_throw_forward_range _Rng2>
+            requires constructible_from<range_value_t<_Rng2>, range_reference_t<_Rng1>>
+        uninitialized_copy_result<borrowed_iterator_t<_Rng1>, borrowed_iterator_t<_Rng2>> operator()(
+            _Rng1&& _Range1, _Rng2&& _Range2) const {
+            // clang-format on
+            auto _First1  = _RANGES begin(_Range1);
+            auto _UResult = _Uninitialized_copy_unchecked(
+                _Get_unwrapped(_STD move(_First1)), _Uend(_Range1), _Ubegin(_Range2), _Uend(_Range2));
+
+            _Seek_wrapped(_First1, _STD move(_UResult.in));
+            return {_STD move(_First1), _Rewrap_iterator(_Range2, _STD move(_UResult.out))};
+        }
+
+    private:
+        template <class _It1, class _Se1, class _It2, class _Se2>
+        _NODISCARD static uninitialized_copy_result<_It1, _It2> _Uninitialized_copy_unchecked(
+            _It1 _IFirst, const _Se1 _ILast, _It2 _OFirst, const _Se2 _OLast) {
+            _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
+            _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_forward_iterator<_It2>);
+            _STL_INTERNAL_STATIC_ASSERT(_No_throw_sentinel_for<_Se2, _It2>);
+            _STL_INTERNAL_STATIC_ASSERT(constructible_from<iter_value_t<_It2>, iter_reference_t<_It1>>);
+
+            if constexpr (is_same_v<_Se1, _It1> && _Ptr_copy_cat<_It1, _It2>::_Really_trivial) {
+                return _Copy_memmove(_IFirst, _ILast, _OLast);
+            } else {
+                _Uninitialized_backout _Backout{_STD move(_OFirst)};
+
+                for (; _IFirst != _ILast && _Backout._Last != _OLast; ++_IFirst) {
+                    _Backout._Emplace_back(*_IFirst);
+                }
+
+                return {_STD move(_IFirst), _Backout._Release()};
+            }
+        }
+    };
+
+    inline constexpr _Uninitialized_copy_fn uninitialized_copy{_Not_quite_object::_Construct_tag{}};
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
diff --git a/tests/std/test.lst b/tests/std/test.lst
@@ -297,6 +297,7 @@ tests\P0896R4_ranges_alg_shuffle
 tests\P0896R4_ranges_alg_swap_ranges
 tests\P0896R4_ranges_alg_transform_binary
 tests\P0896R4_ranges_alg_transform_unary
+tests\P0896R4_ranges_alg_uninitialized_copy
 tests\P0896R4_ranges_alg_uninitialized_default_construct
 tests\P0896R4_ranges_alg_uninitialized_default_construct_n
 tests\P0896R4_ranges_alg_uninitialized_fill
diff --git a/tests/std/tests/P0896R4_ranges_alg_uninitialized_copy/env.lst b/tests/std/tests/P0896R4_ranges_alg_uninitialized_copy/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_matrix.lst
diff --git a/tests/std/tests/P0896R4_ranges_alg_uninitialized_copy/test.cpp b/tests/std/tests/P0896R4_ranges_alg_uninitialized_copy/test.cpp
@@ -0,0 +1,180 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <memory>
+#include <ranges>
+#include <span>
+#include <utility>
+
+#include <range_algorithm_support.hpp>
+
+using namespace std;
+
+// Validate that uninitialized_copy_result aliases in_out_result
+STATIC_ASSERT(same_as<ranges::uninitialized_copy_result<int, double>, ranges::in_out_result<int, double>>);
+
+// Validate dangling story
+STATIC_ASSERT(same_as<decltype(ranges::uninitialized_copy(borrowed<false>{}, borrowed<false>{})),
+    ranges::uninitialized_copy_result<ranges::dangling, ranges::dangling>>);
+STATIC_ASSERT(same_as<decltype(ranges::uninitialized_copy(borrowed<false>{}, borrowed<true>{})),
+    ranges::uninitialized_copy_result<ranges::dangling, int*>>);
+STATIC_ASSERT(same_as<decltype(ranges::uninitialized_copy(borrowed<true>{}, borrowed<false>{})),
+    ranges::uninitialized_copy_result<int*, ranges::dangling>>);
+STATIC_ASSERT(same_as<decltype(ranges::uninitialized_copy(borrowed<true>{}, borrowed<true>{})),
+    ranges::uninitialized_copy_result<int*, int*>>);
+
+struct int_wrapper {
+    inline static int constructions = 0;
+    inline static int destructions  = 0;
+
+    static void clear_counts() {
+        constructions = 0;
+        destructions  = 0;
+    }
+
+    static constexpr int magic_throwing_val = 29;
+    int val                                 = 10;
+
+    int_wrapper() {
+        ++constructions;
+    }
+    int_wrapper(int x) : val{x} {
+        ++constructions;
+    }
+
+    int_wrapper(const int_wrapper& that) {
+        if (that.val == magic_throwing_val) {
+            throw magic_throwing_val;
+        }
+
+        val = exchange(that.val, -1);
+        ++constructions;
+    }
+
+    ~int_wrapper() {
+        ++destructions;
+    }
+
+    int_wrapper& operator=(const int_wrapper& that) {
+        if (that.val == magic_throwing_val) {
+            throw magic_throwing_val;
+        }
+        val = exchange(that.val, -1);
+        return *this;
+    }
+
+    auto operator<=>(const int_wrapper&) const = default;
+};
+
+template <class T, size_t N>
+struct holder {
+    STATIC_ASSERT(N < ~size_t{0} / sizeof(T));
+    alignas(T) unsigned char space[N * sizeof(T)];
+
+    auto as_span() {
+        return span<T, N>{reinterpret_cast<T*>(space + 0), N};
+    }
+};
+
+template <class R>
+void not_ranges_destroy(R&& r) { // TRANSITION, ranges::destroy
+    for (auto& e : r) {
+        destroy_at(&e);
+    }
+}
+
+struct instantiator {
+    static constexpr int expected_output[] = {13, 55, 12345};
+    static constexpr int expected_input[]  = {-1, -1, -1};
+
+    template <ranges::input_range R, ranges::forward_range W>
+    static void call() {
+        using ranges::uninitialized_copy, ranges::uninitialized_copy_result, ranges::equal, ranges::equal_to,
+            ranges::iterator_t;
+
+        { // Validate range overload
+            int_wrapper input[3] = {13, 55, 12345};
+            R wrapped_input{input};
+            holder<int_wrapper, 3> mem;
+            W wrapped_output{mem.as_span()};
+
+            int_wrapper::clear_counts();
+            const same_as<uninitialized_copy_result<iterator_t<R>, iterator_t<W>>> auto result =
+                uninitialized_copy(wrapped_input, wrapped_output);
+            assert(int_wrapper::constructions == 3);
+            assert(int_wrapper::destructions == 0);
+            assert(result.in == wrapped_input.end());
+            assert(result.out == wrapped_output.end());
+            assert(equal(wrapped_output, expected_output, equal_to{}, &int_wrapper::val));
+            assert(equal(input, expected_input, equal_to{}, &int_wrapper::val));
+            not_ranges_destroy(wrapped_output);
+            assert(int_wrapper::constructions == 3);
+            assert(int_wrapper::destructions == 3);
+        }
+
+        { // Validate iterator overload
+            int_wrapper input[3] = {13, 55, 12345};
+            R wrapped_input{input};
+            holder<int_wrapper, 3> mem;
+            W wrapped_output{mem.as_span()};
+
+            int_wrapper::clear_counts();
+            const same_as<uninitialized_copy_result<iterator_t<R>, iterator_t<W>>> auto result = uninitialized_copy(
+                wrapped_input.begin(), wrapped_input.end(), wrapped_output.begin(), wrapped_output.end());
+            assert(int_wrapper::constructions == 3);
+            assert(int_wrapper::destructions == 0);
+            assert(result.in == wrapped_input.end());
+            assert(result.out == wrapped_output.end());
+            assert(equal(wrapped_output, expected_output, equal_to{}, &int_wrapper::val));
+            assert(equal(input, expected_input, equal_to{}, &int_wrapper::val));
+            not_ranges_destroy(wrapped_output);
+            assert(int_wrapper::constructions == 3);
+            assert(int_wrapper::destructions == 3);
+        }
+    }
+};
+
+struct throwing_test {
+    static constexpr int expected_input[] = {-1, -1, int_wrapper::magic_throwing_val, 12345};
+
+    template <ranges::input_range R, ranges::forward_range W>
+    static void call() {
+        // Validate only range overload (one is plenty since they both use the same backend)
+        int_wrapper input[] = {13, 55, int_wrapper::magic_throwing_val, 12345};
+        R wrapped_input{input};
+        holder<int_wrapper, 4> mem;
+        W wrapped_output{mem.as_span()};
+
+        int_wrapper::clear_counts();
+        try {
+            (void) ranges::uninitialized_copy(wrapped_input, wrapped_output);
+            assert(false);
+        } catch (int i) {
+            assert(i == int_wrapper::magic_throwing_val);
+        } catch (...) {
+            assert(false);
+        }
+        assert(int_wrapper::constructions == 2);
+        assert(int_wrapper::destructions == 2);
+        assert(ranges::equal(input, expected_input, ranges::equal_to{}, &int_wrapper::val));
+    }
+};
+
+template <test::ProxyRef IsProxy>
+using test_input  = test::range<test::input, int_wrapper, test::Sized::no, test::CanDifference::no, test::Common::no,
+    test::CanCompare::yes, IsProxy>;
+using test_output = test::range<test::fwd, int_wrapper, test::Sized::no, test::CanDifference::no, test::Common::no,
+    test::CanCompare::yes, test::ProxyRef::no>;
+
+int main() {
+    // The algorithm is oblivious to non-required category, size, difference, and "proxyness" of the input range. It
+    // _is_ sensitive to proxyness in that it requires non-proxy references for the output range.
+
+    instantiator::call<test_input<test::ProxyRef::no>, test_output>();
+    instantiator::call<test_input<test::ProxyRef::yes>, test_output>();
+    throwing_test::call<test_input<test::ProxyRef::no>, test_output>();
+    throwing_test::call<test_input<test::ProxyRef::yes>, test_output>();
+}
