libcxx/test/std/iterators/iterator.requirements/iterator.concepts/incrementable.h

   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_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
  10 #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H
  11
  12 struct postfix_increment_returns_void {
  13   using difference_type = int;
  14   postfix_increment_returns_void& operator++();
  15   void operator++(int);
  16 };
  17
  18 struct postfix_increment_returns_copy {
  19   using difference_type = int;
  20   postfix_increment_returns_copy& operator++();
  21   postfix_increment_returns_copy operator++(int);
  22 };
  23
  24 struct has_integral_minus {
  25   has_integral_minus& operator++();
  26   has_integral_minus operator++(int);
  27
  28   long operator-(has_integral_minus) const;
  29 };
  30
  31 struct has_distinct_difference_type_and_minus {
  32   using difference_type = short;
  33
  34   has_distinct_difference_type_and_minus& operator++();
  35   has_distinct_difference_type_and_minus operator++(int);
  36
  37   long operator-(has_distinct_difference_type_and_minus) const;
  38 };
  39
  40 struct missing_difference_type {
  41   missing_difference_type& operator++();
  42   void operator++(int);
  43 };
  44
  45 struct floating_difference_type {
  46   using difference_type = float;
  47
  48   floating_difference_type& operator++();
  49   void operator++(int);
  50 };
  51
  52 struct non_const_minus {
  53   non_const_minus& operator++();
  54   non_const_minus operator++(int);
  55
  56   long operator-(non_const_minus);
  57 };
  58
  59 struct non_integral_minus {
  60   non_integral_minus& operator++();
  61   non_integral_minus operator++(int);
  62
  63   void operator-(non_integral_minus);
  64 };
  65
  66 struct bad_difference_type_good_minus {
  67   using difference_type = float;
  68
  69   bad_difference_type_good_minus& operator++();
  70   void operator++(int);
  71
  72   int operator-(bad_difference_type_good_minus) const;
  73 };
  74
  75 struct not_default_initializable {
  76   using difference_type = int;
  77   not_default_initializable() = delete;
  78
  79   not_default_initializable& operator++();
  80   void operator++(int);
  81 };
  82
  83 struct not_movable {
  84   using difference_type = int;
  85
  86   not_movable() = default;
  87   not_movable(not_movable&&) = delete;
  88
  89   not_movable& operator++();
  90   void operator++(int);
  91 };
  92
  93 struct preinc_not_declared {
  94   using difference_type = int;
  95
  96   void operator++(int);
  97 };
  98
  99 struct postinc_not_declared {
 100   using difference_type = int;
 101
 102   postinc_not_declared& operator++();
 103 };
 104
 105 struct incrementable_with_difference_type {
 106   using difference_type = int;
 107
 108   incrementable_with_difference_type& operator++();
 109   incrementable_with_difference_type operator++(int);
 110
 111   bool operator==(incrementable_with_difference_type const&) const;
 112 };
 113
 114 struct incrementable_without_difference_type {
 115   incrementable_without_difference_type& operator++();
 116   incrementable_without_difference_type operator++(int);
 117
 118   bool operator==(incrementable_without_difference_type const&) const;
 119
 120   int operator-(incrementable_without_difference_type) const;
 121 };
 122
 123 struct difference_type_and_void_minus {
 124   using difference_type = int;
 125
 126   difference_type_and_void_minus& operator++();
 127   difference_type_and_void_minus operator++(int);
 128
 129   bool operator==(difference_type_and_void_minus const&) const;
 130
 131   void operator-(difference_type_and_void_minus) const;
 132 };
 133
 134 struct noncopyable_with_difference_type {
 135   using difference_type = int;
 136
 137   noncopyable_with_difference_type() = default;
 138   noncopyable_with_difference_type(noncopyable_with_difference_type&&) = default;
 139   noncopyable_with_difference_type(noncopyable_with_difference_type const&) = delete;
 140
 141   noncopyable_with_difference_type& operator=(noncopyable_with_difference_type&&) = default;
 142   noncopyable_with_difference_type& operator=(noncopyable_with_difference_type const&) = delete;
 143
 144   noncopyable_with_difference_type& operator++();
 145   noncopyable_with_difference_type operator++(int);
 146
 147   bool operator==(noncopyable_with_difference_type const&) const;
 148 };
 149
 150 struct noncopyable_without_difference_type {
 151   noncopyable_without_difference_type() = default;
 152   noncopyable_without_difference_type(noncopyable_without_difference_type&&) = default;
 153   noncopyable_without_difference_type(noncopyable_without_difference_type const&) = delete;
 154
 155   noncopyable_without_difference_type& operator=(noncopyable_without_difference_type&&) = default;
 156   noncopyable_without_difference_type& operator=(noncopyable_without_difference_type const&) = delete;
 157
 158   noncopyable_without_difference_type& operator++();
 159   noncopyable_without_difference_type operator++(int);
 160
 161   int operator-(noncopyable_without_difference_type const&) const;
 162
 163   bool operator==(noncopyable_without_difference_type const&) const;
 164 };
 165
 166 struct noncopyable_with_difference_type_and_minus {
 167   using difference_type = int;
 168
 169   noncopyable_with_difference_type_and_minus() = default;
 170   noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus&&) = default;
 171   noncopyable_with_difference_type_and_minus(noncopyable_with_difference_type_and_minus const&) = delete;
 172
 173   noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus&&) = default;
 174   noncopyable_with_difference_type_and_minus& operator=(noncopyable_with_difference_type_and_minus const&) = delete;
 175
 176   noncopyable_with_difference_type_and_minus& operator++();
 177   noncopyable_with_difference_type_and_minus operator++(int);
 178
 179   int operator-(noncopyable_with_difference_type_and_minus const&) const;
 180
 181   bool operator==(noncopyable_with_difference_type_and_minus const&) const;
 182 };
 183
 184 #endif // #define LIBCPP_TEST_STD_ITERATORS_ITERATOR_REQUIREMENTS_ITERATOR_CONCEPTS_INCREMENTABLE_H