| //===----------------------------------------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| // <iterator> |
| |
| // move_iterator |
| |
| // Test nested types: |
| |
| // template <InputIterator Iter> |
| // class move_iterator { |
| // public: |
| // using iterator_type = Iterator; |
| // using iterator_concept = see below; // From C++20 |
| // using iterator_category = see below; // not always present starting from C++20 |
| // using value_type = iter_value_t<Iterator>; // Until C++20, iterator_traits<Iterator>::value_type |
| // using difference_type = iter_difference_t<Iterator>; // Until C++20, iterator_traits<Iterator>::difference_type; |
| // using pointer = Iterator; |
| // using reference = iter_rvalue_reference_t<Iterator>; // Until C++20, value_type&& |
| // }; |
| |
| #include <functional> |
| #include <iterator> |
| #include <type_traits> |
| |
| #include "test_macros.h" |
| #include "test_iterators.h" |
| |
| struct FooIter { |
| using iterator_category = std::bidirectional_iterator_tag; |
| using value_type = void*; |
| using difference_type = void*; |
| using pointer = void*; |
| using reference = char&; |
| bool& operator*() const; |
| }; |
| |
| #if TEST_STD_VER > 17 |
| template <> |
| struct std::indirectly_readable_traits<FooIter> { |
| using value_type = int; |
| }; |
| template <> |
| struct std::incrementable_traits<FooIter> { |
| using difference_type = char; |
| }; |
| #endif |
| |
| #if TEST_STD_VER > 17 |
| // Not using `FooIter::value_type`. |
| static_assert(std::is_same_v<typename std::move_iterator<FooIter>::value_type, int>); |
| // Not using `FooIter::difference_type`. |
| static_assert(std::is_same_v<typename std::move_iterator<FooIter>::difference_type, char>); |
| static_assert(std::is_same_v<typename std::reverse_iterator<FooIter>::reference, bool&>); |
| |
| #else |
| static_assert(std::is_same<typename std::reverse_iterator<FooIter>::reference, char&>::value, ""); |
| #endif |
| |
| template <class ValueType, class Reference> |
| struct DummyIt { |
| typedef std::forward_iterator_tag iterator_category; |
| typedef ValueType value_type; |
| typedef std::ptrdiff_t difference_type; |
| typedef ValueType* pointer; |
| typedef Reference reference; |
| |
| Reference operator*() const; |
| }; |
| |
| template <class It> |
| void test() { |
| typedef std::move_iterator<It> R; |
| typedef std::iterator_traits<It> T; |
| static_assert((std::is_same<typename R::iterator_type, It>::value), ""); |
| static_assert((std::is_same<typename R::difference_type, typename T::difference_type>::value), ""); |
| static_assert((std::is_same<typename R::pointer, It>::value), ""); |
| static_assert((std::is_same<typename R::value_type, typename T::value_type>::value), ""); |
| |
| #if TEST_STD_VER > 17 |
| static_assert((std::is_same_v<typename R::reference, std::iter_rvalue_reference_t<It>>), ""); |
| #else |
| static_assert((std::is_same<typename R::reference, typename R::value_type&&>::value), ""); |
| #endif |
| |
| #if TEST_STD_VER > 17 |
| if constexpr (std::is_same_v<typename T::iterator_category, std::contiguous_iterator_tag>) { |
| static_assert((std::is_same<typename R::iterator_category, std::random_access_iterator_tag>::value), ""); |
| } else { |
| static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), ""); |
| } |
| #else |
| static_assert((std::is_same<typename R::iterator_category, typename T::iterator_category>::value), ""); |
| #endif |
| |
| #if TEST_STD_VER > 17 |
| static_assert( |
| std::is_same_v<typename R::iterator_concept, |
| std::conditional_t<std::is_same_v<typename R::iterator_concept, std::contiguous_iterator_tag>, |
| std::random_access_iterator_tag, |
| typename R::iterator_concept>>); |
| #endif |
| } |
| |
| int main(int, char**) { |
| test<cpp17_input_iterator<char*> >(); |
| test<forward_iterator<char*> >(); |
| test<bidirectional_iterator<char*> >(); |
| test<random_access_iterator<char*> >(); |
| test<char*>(); |
| |
| #if TEST_STD_VER >= 11 |
| { |
| typedef DummyIt<int, int> T; |
| typedef std::move_iterator<T> It; |
| static_assert(std::is_same<It::reference, int>::value, ""); |
| } |
| { |
| typedef DummyIt<int, std::reference_wrapper<int> > T; |
| typedef std::move_iterator<T> It; |
| static_assert(std::is_same<It::reference, std::reference_wrapper<int> >::value, ""); |
| } |
| { |
| // Check that move_iterator uses whatever reference type it's given |
| // when it's not a reference. |
| typedef DummyIt<int, long > T; |
| typedef std::move_iterator<T> It; |
| static_assert(std::is_same<It::reference, long>::value, ""); |
| } |
| { |
| typedef DummyIt<int, int&> T; |
| typedef std::move_iterator<T> It; |
| static_assert(std::is_same<It::reference, int&&>::value, ""); |
| } |
| { |
| typedef DummyIt<int, int&&> T; |
| typedef std::move_iterator<T> It; |
| static_assert(std::is_same<It::reference, int&&>::value, ""); |
| } |
| #endif |
| |
| #if TEST_STD_VER > 17 |
| test<contiguous_iterator<char*>>(); |
| static_assert(std::is_same_v<typename std::move_iterator<forward_iterator<char*>>::iterator_concept, std::forward_iterator_tag>); |
| static_assert(std::is_same_v<typename std::move_iterator<bidirectional_iterator<char*>>::iterator_concept, std::bidirectional_iterator_tag>); |
| static_assert(std::is_same_v<typename std::move_iterator<random_access_iterator<char*>>::iterator_concept, std::random_access_iterator_tag>); |
| static_assert(std::is_same_v<typename std::move_iterator<contiguous_iterator<char*>>::iterator_concept, std::random_access_iterator_tag>); |
| static_assert(std::is_same_v<typename std::move_iterator<char*>::iterator_concept, std::random_access_iterator_tag>); |
| #endif |
| |
| return 0; |
| } |