1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef _LIBCPP___ALGORITHM_RANGES_TRANSFORM_H
10#define _LIBCPP___ALGORITHM_RANGES_TRANSFORM_H
11
12#include <__algorithm/in_in_out_result.h>
13#include <__algorithm/in_out_result.h>
14#include <__concepts/constructible.h>
15#include <__config>
16#include <__functional/identity.h>
17#include <__functional/invoke.h>
18#include <__iterator/concepts.h>
19#include <__iterator/projected.h>
20#include <__ranges/access.h>
21#include <__ranges/concepts.h>
22#include <__ranges/dangling.h>
23#include <__utility/move.h>
24
25#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
26#  pragma GCC system_header
27#endif
28
29_LIBCPP_PUSH_MACROS
30#include <__undef_macros>
31
32#if _LIBCPP_STD_VER >= 20
33
34_LIBCPP_BEGIN_NAMESPACE_STD
35
36namespace ranges {
37
38template <class _Ip, class _Op>
39using unary_transform_result = in_out_result<_Ip, _Op>;
40
41template <class _I1, class _I2, class _O1>
42using binary_transform_result = in_in_out_result<_I1, _I2, _O1>;
43
44namespace __transform {
45struct __fn {
46private:
47  template <class _InIter, class _Sent, class _OutIter, class _Func, class _Proj>
48  _LIBCPP_HIDE_FROM_ABI static constexpr unary_transform_result<_InIter, _OutIter>
49  __unary(_InIter __first, _Sent __last, _OutIter __result, _Func& __operation, _Proj& __projection) {
50    while (__first != __last) {
51      *__result = std::invoke(__operation, std::invoke(__projection, *__first));
52      ++__first;
53      ++__result;
54    }
55
56    return {std::move(__first), std::move(__result)};
57  }
58
59  template <class _InIter1,
60            class _Sent1,
61            class _InIter2,
62            class _Sent2,
63            class _OutIter,
64            class _Func,
65            class _Proj1,
66            class _Proj2>
67  _LIBCPP_HIDE_FROM_ABI static constexpr binary_transform_result<_InIter1, _InIter2, _OutIter>
68  __binary(_InIter1 __first1,
69           _Sent1 __last1,
70           _InIter2 __first2,
71           _Sent2 __last2,
72           _OutIter __result,
73           _Func& __binary_operation,
74           _Proj1& __projection1,
75           _Proj2& __projection2) {
76    while (__first1 != __last1 && __first2 != __last2) {
77      *__result =
78          std::invoke(__binary_operation, std::invoke(__projection1, *__first1), std::invoke(__projection2, *__first2));
79      ++__first1;
80      ++__first2;
81      ++__result;
82    }
83    return {std::move(__first1), std::move(__first2), std::move(__result)};
84  }
85
86public:
87  template <input_iterator _InIter,
88            sentinel_for<_InIter> _Sent,
89            weakly_incrementable _OutIter,
90            copy_constructible _Func,
91            class _Proj = identity>
92    requires indirectly_writable<_OutIter, indirect_result_t<_Func&, projected<_InIter, _Proj>>>
93  _LIBCPP_HIDE_FROM_ABI constexpr unary_transform_result<_InIter, _OutIter>
94  operator()(_InIter __first, _Sent __last, _OutIter __result, _Func __operation, _Proj __proj = {}) const {
95    return __unary(std::move(__first), std::move(__last), std::move(__result), __operation, __proj);
96  }
97
98  template <input_range _Range, weakly_incrementable _OutIter, copy_constructible _Func, class _Proj = identity>
99    requires indirectly_writable<_OutIter, indirect_result_t<_Func, projected<iterator_t<_Range>, _Proj>>>
100  _LIBCPP_HIDE_FROM_ABI constexpr unary_transform_result<borrowed_iterator_t<_Range>, _OutIter>
101  operator()(_Range&& __range, _OutIter __result, _Func __operation, _Proj __projection = {}) const {
102    return __unary(ranges::begin(__range), ranges::end(__range), std::move(__result), __operation, __projection);
103  }
104
105  template <input_iterator _InIter1,
106            sentinel_for<_InIter1> _Sent1,
107            input_iterator _InIter2,
108            sentinel_for<_InIter2> _Sent2,
109            weakly_incrementable _OutIter,
110            copy_constructible _Func,
111            class _Proj1 = identity,
112            class _Proj2 = identity>
113    requires indirectly_writable<_OutIter,
114                                 indirect_result_t<_Func&, projected<_InIter1, _Proj1>, projected<_InIter2, _Proj2>>>
115  _LIBCPP_HIDE_FROM_ABI constexpr binary_transform_result<_InIter1, _InIter2, _OutIter> operator()(
116      _InIter1 __first1,
117      _Sent1 __last1,
118      _InIter2 __first2,
119      _Sent2 __last2,
120      _OutIter __result,
121      _Func __binary_operation,
122      _Proj1 __projection1 = {},
123      _Proj2 __projection2 = {}) const {
124    return __binary(
125        std::move(__first1),
126        std::move(__last1),
127        std::move(__first2),
128        std::move(__last2),
129        std::move(__result),
130        __binary_operation,
131        __projection1,
132        __projection2);
133  }
134
135  template <input_range _Range1,
136            input_range _Range2,
137            weakly_incrementable _OutIter,
138            copy_constructible _Func,
139            class _Proj1 = identity,
140            class _Proj2 = identity>
141    requires indirectly_writable<
142        _OutIter,
143        indirect_result_t<_Func&, projected<iterator_t<_Range1>, _Proj1>, projected<iterator_t<_Range2>, _Proj2>>>
144  _LIBCPP_HIDE_FROM_ABI constexpr binary_transform_result<borrowed_iterator_t<_Range1>,
145                                                          borrowed_iterator_t<_Range2>,
146                                                          _OutIter>
147  operator()(_Range1&& __range1,
148             _Range2&& __range2,
149             _OutIter __result,
150             _Func __binary_operation,
151             _Proj1 __projection1 = {},
152             _Proj2 __projection2 = {}) const {
153    return __binary(
154        ranges::begin(__range1),
155        ranges::end(__range1),
156        ranges::begin(__range2),
157        ranges::end(__range2),
158        std::move(__result),
159        __binary_operation,
160        __projection1,
161        __projection2);
162  }
163};
164} // namespace __transform
165
166inline namespace __cpo {
167inline constexpr auto transform = __transform::__fn{};
168} // namespace __cpo
169} // namespace ranges
170
171_LIBCPP_END_NAMESPACE_STD
172
173#endif // _LIBCPP_STD_VER >= 20
174
175_LIBCPP_POP_MACROS
176
177#endif // _LIBCPP___ALGORITHM_RANGES_TRANSFORM_H
178