1 //===----------------------------------------------------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is dual licensed under the MIT and the University of Illinois Open 6 // Source Licenses. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 // <unordered_set> 11 12 // template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, 13 // class Alloc = allocator<Value>> 14 // class unordered_multiset 15 16 // local_iterator begin (size_type n); 17 // local_iterator end (size_type n); 18 // const_local_iterator begin (size_type n) const; 19 // const_local_iterator end (size_type n) const; 20 // const_local_iterator cbegin(size_type n) const; 21 // const_local_iterator cend (size_type n) const; 22 23 #include <unordered_set> 24 #include <cassert> 25 26 int main() 27 { 28 { 29 typedef std::unordered_multiset<int> C; 30 typedef int P; 31 typedef C::local_iterator I; 32 P a[] = 33 { 34 P(1), 35 P(2), 36 P(3), 37 P(4), 38 P(1), 39 P(2) 40 }; 41 C c(a, a + sizeof(a)/sizeof(a[0])); 42 assert(c.bucket_count() >= 7); 43 C::size_type b = c.bucket(0); 44 I i = c.begin(b); 45 I j = c.end(b); 46 assert(std::distance(i, j) == 0); 47 48 b = c.bucket(1); 49 i = c.begin(b); 50 j = c.end(b); 51 assert(std::distance(i, j) == 2); 52 assert(*i == 1); 53 ++i; 54 assert(*i == 1); 55 56 b = c.bucket(2); 57 i = c.begin(b); 58 j = c.end(b); 59 assert(std::distance(i, j) == 2); 60 assert(*i == 2); 61 ++i; 62 assert(*i == 2); 63 64 b = c.bucket(3); 65 i = c.begin(b); 66 j = c.end(b); 67 assert(std::distance(i, j) == 1); 68 assert(*i == 3); 69 70 b = c.bucket(4); 71 i = c.begin(b); 72 j = c.end(b); 73 assert(std::distance(i, j) == 1); 74 assert(*i == 4); 75 76 b = c.bucket(5); 77 i = c.begin(b); 78 j = c.end(b); 79 assert(std::distance(i, j) == 0); 80 81 b = c.bucket(6); 82 i = c.begin(b); 83 j = c.end(b); 84 assert(std::distance(i, j) == 0); 85 } 86 { 87 typedef std::unordered_multiset<int> C; 88 typedef int P; 89 typedef C::const_local_iterator I; 90 P a[] = 91 { 92 P(1), 93 P(2), 94 P(3), 95 P(4), 96 P(1), 97 P(2) 98 }; 99 const C c(a, a + sizeof(a)/sizeof(a[0])); 100 assert(c.bucket_count() >= 7); 101 C::size_type b = c.bucket(0); 102 I i = c.begin(b); 103 I j = c.end(b); 104 assert(std::distance(i, j) == 0); 105 106 b = c.bucket(1); 107 i = c.begin(b); 108 j = c.end(b); 109 assert(std::distance(i, j) == 2); 110 assert(*i == 1); 111 ++i; 112 assert(*i == 1); 113 114 b = c.bucket(2); 115 i = c.begin(b); 116 j = c.end(b); 117 assert(std::distance(i, j) == 2); 118 assert(*i == 2); 119 ++i; 120 assert(*i == 2); 121 122 b = c.bucket(3); 123 i = c.begin(b); 124 j = c.end(b); 125 assert(std::distance(i, j) == 1); 126 assert(*i == 3); 127 128 b = c.bucket(4); 129 i = c.begin(b); 130 j = c.end(b); 131 assert(std::distance(i, j) == 1); 132 assert(*i == 4); 133 134 b = c.bucket(5); 135 i = c.begin(b); 136 j = c.end(b); 137 assert(std::distance(i, j) == 0); 138 139 b = c.bucket(6); 140 i = c.begin(b); 141 j = c.end(b); 142 assert(std::distance(i, j) == 0); 143 } 144 { 145 typedef std::unordered_multiset<int> C; 146 typedef int P; 147 typedef C::const_local_iterator I; 148 P a[] = 149 { 150 P(1), 151 P(2), 152 P(3), 153 P(4), 154 P(1), 155 P(2) 156 }; 157 C c(a, a + sizeof(a)/sizeof(a[0])); 158 assert(c.bucket_count() >= 7); 159 C::size_type b = c.bucket(0); 160 I i = c.cbegin(b); 161 I j = c.cend(b); 162 assert(std::distance(i, j) == 0); 163 164 b = c.bucket(1); 165 i = c.cbegin(b); 166 j = c.cend(b); 167 assert(std::distance(i, j) == 2); 168 assert(*i == 1); 169 ++i; 170 assert(*i == 1); 171 172 b = c.bucket(2); 173 i = c.cbegin(b); 174 j = c.cend(b); 175 assert(std::distance(i, j) == 2); 176 assert(*i == 2); 177 ++i; 178 assert(*i == 2); 179 180 b = c.bucket(3); 181 i = c.cbegin(b); 182 j = c.cend(b); 183 assert(std::distance(i, j) == 1); 184 assert(*i == 3); 185 186 b = c.bucket(4); 187 i = c.cbegin(b); 188 j = c.cend(b); 189 assert(std::distance(i, j) == 1); 190 assert(*i == 4); 191 192 b = c.bucket(5); 193 i = c.cbegin(b); 194 j = c.cend(b); 195 assert(std::distance(i, j) == 0); 196 197 b = c.bucket(6); 198 i = c.cbegin(b); 199 j = c.cend(b); 200 assert(std::distance(i, j) == 0); 201 } 202 { 203 typedef std::unordered_multiset<int> C; 204 typedef int P; 205 typedef C::const_local_iterator I; 206 P a[] = 207 { 208 P(1), 209 P(2), 210 P(3), 211 P(4), 212 P(1), 213 P(2) 214 }; 215 const C c(a, a + sizeof(a)/sizeof(a[0])); 216 assert(c.bucket_count() >= 7); 217 C::size_type b = c.bucket(0); 218 I i = c.cbegin(b); 219 I j = c.cend(b); 220 assert(std::distance(i, j) == 0); 221 222 b = c.bucket(1); 223 i = c.cbegin(b); 224 j = c.cend(b); 225 assert(std::distance(i, j) == 2); 226 assert(*i == 1); 227 ++i; 228 assert(*i == 1); 229 230 b = c.bucket(2); 231 i = c.cbegin(b); 232 j = c.cend(b); 233 assert(std::distance(i, j) == 2); 234 assert(*i == 2); 235 ++i; 236 assert(*i == 2); 237 238 b = c.bucket(3); 239 i = c.cbegin(b); 240 j = c.cend(b); 241 assert(std::distance(i, j) == 1); 242 assert(*i == 3); 243 244 b = c.bucket(4); 245 i = c.cbegin(b); 246 j = c.cend(b); 247 assert(std::distance(i, j) == 1); 248 assert(*i == 4); 249 250 b = c.bucket(5); 251 i = c.cbegin(b); 252 j = c.cend(b); 253 assert(std::distance(i, j) == 0); 254 255 b = c.bucket(6); 256 i = c.cbegin(b); 257 j = c.cend(b); 258 assert(std::distance(i, j) == 0); 259 } 260 } 261
