From 99894b61baaa37fd03d0311e882e731dd143f1e6 Mon Sep 17 00:00:00 2001 From: Marshall Clow <mclow.lists@gmail.com> Date: Fri, 19 Jan 2018 17:45:39 +0000 Subject: [PATCH] More P0202 constexpr-ifying in <algorithm>. This commit handles 'transform'. llvm-svn: 322970 --- libcxx/include/algorithm | 8 +++--- .../alg.transform/binary_transform.pass.cpp | 25 +++++++++++++++++- .../alg.transform/unary_transform.pass.cpp | 26 +++++++++++++++++-- 3 files changed, 52 insertions(+), 7 deletions(-) diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm index 4672810a21a2..9ec146a6798e 100644 --- a/libcxx/include/algorithm +++ b/libcxx/include/algorithm @@ -193,11 +193,11 @@ template <class ForwardIterator1, class ForwardIterator2> iter_swap(ForwardIterator1 a, ForwardIterator2 b); template <class InputIterator, class OutputIterator, class UnaryOperation> - OutputIterator + constexpr OutputIterator // constexpr in C++20 transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); template <class InputIterator1, class InputIterator2, class OutputIterator, class BinaryOperation> - OutputIterator + constexpr OutputIterator // constexpr in C++20 transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op); @@ -1946,7 +1946,7 @@ move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last, // transform template <class _InputIterator, class _OutputIterator, class _UnaryOperation> -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator transform(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _UnaryOperation __op) { @@ -1956,7 +1956,7 @@ transform(_InputIterator __first, _InputIterator __last, _OutputIterator __resul } template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _BinaryOperation> -inline _LIBCPP_INLINE_VISIBILITY +inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 _OutputIterator transform(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _OutputIterator __result, _BinaryOperation __binary_op) diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp index 8491ea59eff6..27d3a968a768 100644 --- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp +++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/binary_transform.pass.cpp @@ -12,15 +12,34 @@ // template<InputIterator InIter1, InputIterator InIter2, class OutIter, // Callable<auto, const InIter1::value_type&, const InIter2::value_type&> BinaryOp> // requires OutputIterator<OutIter, BinaryOp::result_type> && CopyConstructible<BinaryOp> -// OutIter +// constexpr OutIter // constexpr after C++17 // transform(InIter1 first1, InIter1 last1, InIter2 first2, OutIter result, BinaryOp binary_op); #include <algorithm> #include <functional> #include <cassert> +#include "test_macros.h" #include "test_iterators.h" +#if TEST_STD_VER > 17 +TEST_CONSTEXPR bool test_constexpr() { + const int ia[] = {1, 3, 6, 7}; + const int ib[] = {2, 4, 7, 8}; + int ic[] = {0, 0, 0, 0, 0}; // one bigger + const int expected[] = {3, 7, 13, 15}; + + auto it = std::transform(std::begin(ia), std::end(ia), + std::begin(ib), std::begin(ic), std::plus<int>()); + + return it == (std::begin(ic) + std::size(ia)) + && *it == 0 // don't overwrite the last value in the output array + && std::equal(std::begin(expected), std::end(expected), std::begin(ic), it) + ; + } +#endif + + template<class InIter1, class InIter2, class OutIter> void test() @@ -214,4 +233,8 @@ int main() test<const int*, const int*, bidirectional_iterator<int*> >(); test<const int*, const int*, random_access_iterator<int*> >(); test<const int*, const int*, int*>(); + +#if TEST_STD_VER > 17 + static_assert(test_constexpr()); +#endif } diff --git a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp index 6c5e621e4b20..b6f9cbad00fe 100644 --- a/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp +++ b/libcxx/test/std/algorithms/alg.modifying.operations/alg.transform/unary_transform.pass.cpp @@ -12,16 +12,34 @@ // template<InputIterator InIter, class OutIter, // Callable<auto, const InIter::value_type&> Op> // requires OutputIterator<OutIter, Op::result_type> && CopyConstructible<Op> -// OutIter +// constexpr OutIter // constexpr after C++17 // transform(InIter first, InIter last, OutIter result, Op op); #include <algorithm> #include <functional> #include <cassert> +#include "test_macros.h" #include "test_iterators.h" -int plusOne(int v) { return v + 1; } +TEST_CONSTEXPR int plusOne(int v) { return v + 1; } + + +#if TEST_STD_VER > 17 +TEST_CONSTEXPR bool test_constexpr() { + int ia[] = {1, 3, 6, 7}; + int ib[] = {0, 0, 0, 0, 0}; // one bigger + const int expected[] = {2, 4, 7, 8}; + + auto it = std::transform(std::begin(ia), std::end(ia), std::begin(ib), plusOne); + + return it == (std::begin(ib) + std::size(ia)) + && *it == 0 // don't overwrite the last value in the output array + && std::equal(std::begin(ib), it, std::begin(expected), std::end(expected)) + ; + } +#endif + template <class InIter, class OutIter> void @@ -76,4 +94,8 @@ int main() test<const int*, bidirectional_iterator<int*> >(); test<const int*, random_access_iterator<int*> >(); test<const int*, int*>(); + +#if TEST_STD_VER > 17 + static_assert(test_constexpr()); +#endif }