| //===----------------------------------------------------------------------===// |
| // |
| // 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 |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H |
| #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H |
| |
| struct postfix_increment_returns_void { |
| using difference_type = int; |
| postfix_increment_returns_void& operator++(); |
| void operator++(int); |
| }; |
| |
| struct postfix_increment_returns_copy { |
| using difference_type = int; |
| postfix_increment_returns_copy& operator++(); |
| postfix_increment_returns_copy operator++(int); |
| }; |
| |
| struct has_integral_minus { |
| has_integral_minus& operator++(); |
| has_integral_minus operator++(int); |
| |
| long operator-(has_integral_minus) const; |
| }; |
| |
| struct has_distinct_difference_type_and_minus { |
| using difference_type = short; |
| |
| has_distinct_difference_type_and_minus& operator++(); |
| has_distinct_difference_type_and_minus operator++(int); |
| |
| long operator-(has_distinct_difference_type_and_minus) const; |
| }; |
| |
| struct missing_difference_type { |
| missing_difference_type& operator++(); |
| void operator++(int); |
| }; |
| |
| struct floating_difference_type { |
| using difference_type = float; |
| |
| floating_difference_type& operator++(); |
| void operator++(int); |
| }; |
| |
| struct non_const_minus { |
| non_const_minus& operator++(); |
| non_const_minus operator++(int); |
| |
| long operator-(non_const_minus); |
| }; |
| |
| struct non_integral_minus { |
| non_integral_minus& operator++(); |
| non_integral_minus operator++(int); |
| |
| void operator-(non_integral_minus); |
| }; |
| |
| struct bad_difference_type_good_minus { |
| using difference_type = float; |
| |
| bad_difference_type_good_minus& operator++(); |
| void operator++(int); |
| |
| int operator-(bad_difference_type_good_minus) const; |
| }; |
| |
| struct not_default_initializable { |
| using difference_type = int; |
| not_default_initializable() = delete; |
| |
| not_default_initializable& operator++(); |
| void operator++(int); |
| }; |
| |
| struct not_movable { |
| using difference_type = int; |
| |
| not_movable() = default; |
| not_movable(not_movable&&) = delete; |
| |
| not_movable& operator++(); |
| void operator++(int); |
| }; |
| |
| struct preinc_not_declared { |
| using difference_type = int; |
| |
| void operator++(int); |
| }; |
| |
| struct postinc_not_declared { |
| using difference_type = int; |
| |
| postinc_not_declared& operator++(); |
| }; |
| |
| struct incrementable_with_difference_type { |
| using difference_type = int; |
| |
| incrementable_with_difference_type& operator++(); |
| incrementable_with_difference_type operator++(int); |
| |
| bool operator==(incrementable_with_difference_type const&) const; |
| }; |
| |
| struct incrementable_without_difference_type { |
| incrementable_without_difference_type& operator++(); |
| incrementable_without_difference_type operator++(int); |
| |
| bool operator==(incrementable_without_difference_type const&) const; |
| |
| int operator-(incrementable_without_difference_type) const; |
| }; |
| |
| struct difference_type_and_void_minus { |
| using difference_type = int; |
| |
| difference_type_and_void_minus& operator++(); |
| difference_type_and_void_minus operator++(int); |
| |
| bool operator==(difference_type_and_void_minus const&) const; |
| |
| void operator-(difference_type_and_void_minus) const; |
| }; |
| |
| struct noncopyable_with_difference_type { |
| using difference_type = int; |
| |
| noncopyable_with_difference_type() = default; |
| noncopyable_with_difference_type(noncopyable_with_difference_type&&) = default; |
| noncopyable_with_difference_type(noncopyable_with_difference_type const&) = delete; |
| |
| noncopyable_with_difference_type& operator=(noncopyable_with_difference_type&&) = default; |
| noncopyable_with_difference_type& operator=(noncopyable_with_difference_type const&) = delete; |
| |
| noncopyable_with_difference_type& operator++(); |
| noncopyable_with_difference_type operator++(int); |
| |
| bool operator==(noncopyable_with_difference_type const&) const; |
| }; |
| |
| struct noncopyable_without_difference_type { |
| noncopyable_without_difference_type() = default; |
| noncopyable_without_difference_type(noncopyable_without_difference_type&&) = default; |
| noncopyable_without_difference_type(noncopyable_without_difference_type const&) = delete; |
| |
| noncopyable_without_difference_type& operator=(noncopyable_without_difference_type&&) = default; |
| noncopyable_without_difference_type& operator=(noncopyable_without_difference_type const&) = delete; |
| |
| noncopyable_without_difference_type& operator++(); |
| noncopyable_without_difference_type operator++(int); |
| |
| int operator-(noncopyable_without_difference_type const&) const; |
| |
| bool operator==(noncopyable_without_difference_type const&) const; |
| }; |
| |
| struct noncopyable_with_difference_type_and_minus { |
| using difference_type = int; |
| |
| noncopyable_with_difference_type_and_minus() = default; |
| noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus&&) = default; |
| noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus const&) = delete; |
| |
| noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus&&) = default; |
| noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus const&) = delete; |
| |
| noncopyable_with_difference_type_and_minus& operator++(); |
| noncopyable_with_difference_type_and_minus operator++(int); |
| |
| int operator-(noncopyable_with_difference_type_and_minus const&) const; |
| |
| bool operator==(noncopyable_with_difference_type_and_minus const&) const; |
| }; |
| |
| #endif // #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H |