]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // |
2 | // (C) Copyright Jeremy Siek 2000. | |
3 | // Distributed under the Boost Software License, Version 1.0. (See | |
4 | // accompanying file LICENSE_1_0.txt or copy at | |
5 | // http://www.boost.org/LICENSE_1_0.txt) | |
6 | // | |
7 | // Revision History: | |
8 | // | |
9 | // 17 July 2001: Added const to some member functions. (Jeremy Siek) | |
10 | // 05 May 2001: Removed static dummy_cons object. (Jeremy Siek) | |
11 | ||
12 | // See http://www.boost.org/libs/concept_check for documentation. | |
13 | ||
14 | #ifndef BOOST_CONCEPT_ARCHETYPES_HPP | |
15 | #define BOOST_CONCEPT_ARCHETYPES_HPP | |
16 | ||
17 | #include <boost/config.hpp> | |
92f5a8d4 | 18 | #include <boost/config/workaround.hpp> |
7c673cae | 19 | #include <functional> |
11fdf7f2 TL |
20 | #include <iterator> // iterator tags |
21 | #include <cstddef> // std::ptrdiff_t | |
7c673cae FG |
22 | |
23 | namespace boost { | |
24 | ||
25 | //=========================================================================== | |
26 | // Basic Archetype Classes | |
27 | ||
28 | namespace detail { | |
29 | class dummy_constructor { }; | |
30 | } | |
31 | ||
32 | // A type that models no concept. The template parameter | |
33 | // is only there so that null_archetype types can be created | |
34 | // that have different type. | |
35 | template <class T = int> | |
36 | class null_archetype { | |
37 | private: | |
38 | null_archetype() { } | |
39 | null_archetype(const null_archetype&) { } | |
40 | null_archetype& operator=(const null_archetype&) { return *this; } | |
41 | public: | |
42 | null_archetype(detail::dummy_constructor) { } | |
43 | #ifndef __MWERKS__ | |
44 | template <class TT> | |
45 | friend void dummy_friend(); // just to avoid warnings | |
46 | #endif | |
47 | }; | |
48 | ||
49 | // This is a helper class that provides a way to get a reference to | |
50 | // an object. The get() function will never be called at run-time | |
51 | // (nothing in this file will) so this seemingly very bad function | |
52 | // is really quite innocent. The name of this class needs to be | |
53 | // changed. | |
54 | template <class T> | |
55 | class static_object | |
56 | { | |
57 | public: | |
58 | static T& get() | |
59 | { | |
20effc67 | 60 | #if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) |
7c673cae FG |
61 | return *reinterpret_cast<T*>(0); |
62 | #else | |
63 | static char d[sizeof(T)]; | |
64 | return *reinterpret_cast<T*>(d); | |
65 | #endif | |
66 | } | |
67 | }; | |
68 | ||
69 | template <class Base = null_archetype<> > | |
70 | class default_constructible_archetype : public Base { | |
71 | public: | |
72 | default_constructible_archetype() | |
73 | : Base(static_object<detail::dummy_constructor>::get()) { } | |
74 | default_constructible_archetype(detail::dummy_constructor x) : Base(x) { } | |
75 | }; | |
76 | ||
77 | template <class Base = null_archetype<> > | |
78 | class assignable_archetype : public Base { | |
79 | assignable_archetype() { } | |
80 | assignable_archetype(const assignable_archetype&) { } | |
81 | public: | |
82 | assignable_archetype& operator=(const assignable_archetype&) { | |
83 | return *this; | |
84 | } | |
85 | assignable_archetype(detail::dummy_constructor x) : Base(x) { } | |
86 | }; | |
87 | ||
88 | template <class Base = null_archetype<> > | |
89 | class copy_constructible_archetype : public Base { | |
90 | public: | |
91 | copy_constructible_archetype() | |
92 | : Base(static_object<detail::dummy_constructor>::get()) { } | |
93 | copy_constructible_archetype(const copy_constructible_archetype&) | |
94 | : Base(static_object<detail::dummy_constructor>::get()) { } | |
95 | copy_constructible_archetype(detail::dummy_constructor x) : Base(x) { } | |
96 | }; | |
97 | ||
98 | template <class Base = null_archetype<> > | |
99 | class sgi_assignable_archetype : public Base { | |
100 | public: | |
101 | sgi_assignable_archetype(const sgi_assignable_archetype&) | |
102 | : Base(static_object<detail::dummy_constructor>::get()) { } | |
103 | sgi_assignable_archetype& operator=(const sgi_assignable_archetype&) { | |
104 | return *this; | |
105 | } | |
106 | sgi_assignable_archetype(const detail::dummy_constructor& x) : Base(x) { } | |
107 | }; | |
108 | ||
109 | struct default_archetype_base { | |
110 | default_archetype_base(detail::dummy_constructor) { } | |
111 | }; | |
112 | ||
113 | // Careful, don't use same type for T and Base. That results in the | |
114 | // conversion operator being invalid. Since T is often | |
115 | // null_archetype, can't use null_archetype for Base. | |
116 | template <class T, class Base = default_archetype_base> | |
117 | class convertible_to_archetype : public Base { | |
118 | private: | |
119 | convertible_to_archetype() { } | |
120 | convertible_to_archetype(const convertible_to_archetype& ) { } | |
121 | convertible_to_archetype& operator=(const convertible_to_archetype&) | |
122 | { return *this; } | |
123 | public: | |
124 | convertible_to_archetype(detail::dummy_constructor x) : Base(x) { } | |
125 | operator const T&() const { return static_object<T>::get(); } | |
126 | }; | |
127 | ||
128 | template <class T, class Base = default_archetype_base> | |
129 | class convertible_from_archetype : public Base { | |
130 | private: | |
131 | convertible_from_archetype() { } | |
132 | convertible_from_archetype(const convertible_from_archetype& ) { } | |
133 | convertible_from_archetype& operator=(const convertible_from_archetype&) | |
134 | { return *this; } | |
135 | public: | |
136 | convertible_from_archetype(detail::dummy_constructor x) : Base(x) { } | |
137 | convertible_from_archetype(const T&) { } | |
138 | convertible_from_archetype& operator=(const T&) | |
139 | { return *this; } | |
140 | }; | |
141 | ||
142 | class boolean_archetype { | |
143 | public: | |
144 | boolean_archetype(const boolean_archetype&) { } | |
145 | operator bool() const { return true; } | |
146 | boolean_archetype(detail::dummy_constructor) { } | |
147 | private: | |
148 | boolean_archetype() { } | |
149 | boolean_archetype& operator=(const boolean_archetype&) { return *this; } | |
150 | }; | |
151 | ||
152 | template <class Base = null_archetype<> > | |
153 | class equality_comparable_archetype : public Base { | |
154 | public: | |
155 | equality_comparable_archetype(detail::dummy_constructor x) : Base(x) { } | |
156 | }; | |
157 | template <class Base> | |
158 | boolean_archetype | |
159 | operator==(const equality_comparable_archetype<Base>&, | |
160 | const equality_comparable_archetype<Base>&) | |
161 | { | |
162 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
163 | } | |
164 | template <class Base> | |
165 | boolean_archetype | |
166 | operator!=(const equality_comparable_archetype<Base>&, | |
167 | const equality_comparable_archetype<Base>&) | |
168 | { | |
169 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
170 | } | |
171 | ||
172 | ||
173 | template <class Base = null_archetype<> > | |
174 | class equality_comparable2_first_archetype : public Base { | |
175 | public: | |
176 | equality_comparable2_first_archetype(detail::dummy_constructor x) | |
177 | : Base(x) { } | |
178 | }; | |
179 | template <class Base = null_archetype<> > | |
180 | class equality_comparable2_second_archetype : public Base { | |
181 | public: | |
182 | equality_comparable2_second_archetype(detail::dummy_constructor x) | |
183 | : Base(x) { } | |
184 | }; | |
185 | template <class Base1, class Base2> | |
186 | boolean_archetype | |
187 | operator==(const equality_comparable2_first_archetype<Base1>&, | |
188 | const equality_comparable2_second_archetype<Base2>&) | |
189 | { | |
190 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
191 | } | |
192 | template <class Base1, class Base2> | |
193 | boolean_archetype | |
194 | operator!=(const equality_comparable2_first_archetype<Base1>&, | |
195 | const equality_comparable2_second_archetype<Base2>&) | |
196 | { | |
197 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
198 | } | |
199 | ||
200 | ||
201 | template <class Base = null_archetype<> > | |
202 | class less_than_comparable_archetype : public Base { | |
203 | public: | |
204 | less_than_comparable_archetype(detail::dummy_constructor x) : Base(x) { } | |
205 | }; | |
206 | template <class Base> | |
207 | boolean_archetype | |
208 | operator<(const less_than_comparable_archetype<Base>&, | |
209 | const less_than_comparable_archetype<Base>&) | |
210 | { | |
211 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
212 | } | |
213 | ||
214 | ||
215 | ||
216 | template <class Base = null_archetype<> > | |
217 | class comparable_archetype : public Base { | |
218 | public: | |
219 | comparable_archetype(detail::dummy_constructor x) : Base(x) { } | |
220 | }; | |
221 | template <class Base> | |
222 | boolean_archetype | |
223 | operator<(const comparable_archetype<Base>&, | |
224 | const comparable_archetype<Base>&) | |
225 | { | |
226 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
227 | } | |
228 | template <class Base> | |
229 | boolean_archetype | |
230 | operator<=(const comparable_archetype<Base>&, | |
231 | const comparable_archetype<Base>&) | |
232 | { | |
233 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
234 | } | |
235 | template <class Base> | |
236 | boolean_archetype | |
237 | operator>(const comparable_archetype<Base>&, | |
238 | const comparable_archetype<Base>&) | |
239 | { | |
240 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
241 | } | |
242 | template <class Base> | |
243 | boolean_archetype | |
244 | operator>=(const comparable_archetype<Base>&, | |
245 | const comparable_archetype<Base>&) | |
246 | { | |
247 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); | |
248 | } | |
249 | ||
250 | ||
251 | // The purpose of the optags is so that one can specify | |
252 | // exactly which types the operator< is defined between. | |
253 | // This is useful for allowing the operations: | |
254 | // | |
255 | // A a; B b; | |
256 | // a < b | |
257 | // b < a | |
258 | // | |
259 | // without also allowing the combinations: | |
260 | // | |
261 | // a < a | |
262 | // b < b | |
263 | // | |
264 | struct optag1 { }; | |
265 | struct optag2 { }; | |
266 | struct optag3 { }; | |
267 | ||
268 | #define BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(OP, NAME) \ | |
269 | template <class Base = null_archetype<>, class Tag = optag1 > \ | |
270 | class NAME##_first_archetype : public Base { \ | |
271 | public: \ | |
272 | NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \ | |
273 | }; \ | |
274 | \ | |
275 | template <class Base = null_archetype<>, class Tag = optag1 > \ | |
276 | class NAME##_second_archetype : public Base { \ | |
277 | public: \ | |
278 | NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \ | |
279 | }; \ | |
280 | \ | |
281 | template <class BaseFirst, class BaseSecond, class Tag> \ | |
282 | boolean_archetype \ | |
283 | operator OP (const NAME##_first_archetype<BaseFirst, Tag>&, \ | |
284 | const NAME##_second_archetype<BaseSecond, Tag>&) \ | |
285 | { \ | |
286 | return boolean_archetype(static_object<detail::dummy_constructor>::get()); \ | |
287 | } | |
288 | ||
289 | BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(==, equal_op) | |
290 | BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(!=, not_equal_op) | |
291 | BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<, less_than_op) | |
292 | BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<=, less_equal_op) | |
293 | BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>, greater_than_op) | |
294 | BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>=, greater_equal_op) | |
295 | ||
296 | #define BOOST_DEFINE_OPERATOR_ARCHETYPE(OP, NAME) \ | |
297 | template <class Base = null_archetype<> > \ | |
298 | class NAME##_archetype : public Base { \ | |
299 | public: \ | |
300 | NAME##_archetype(detail::dummy_constructor x) : Base(x) { } \ | |
301 | NAME##_archetype(const NAME##_archetype&) \ | |
302 | : Base(static_object<detail::dummy_constructor>::get()) { } \ | |
303 | NAME##_archetype& operator=(const NAME##_archetype&) { return *this; } \ | |
304 | }; \ | |
305 | template <class Base> \ | |
306 | NAME##_archetype<Base> \ | |
307 | operator OP (const NAME##_archetype<Base>&,\ | |
308 | const NAME##_archetype<Base>&) \ | |
309 | { \ | |
310 | return \ | |
311 | NAME##_archetype<Base>(static_object<detail::dummy_constructor>::get()); \ | |
312 | } | |
313 | ||
314 | BOOST_DEFINE_OPERATOR_ARCHETYPE(+, addable) | |
315 | BOOST_DEFINE_OPERATOR_ARCHETYPE(-, subtractable) | |
316 | BOOST_DEFINE_OPERATOR_ARCHETYPE(*, multipliable) | |
317 | BOOST_DEFINE_OPERATOR_ARCHETYPE(/, dividable) | |
318 | BOOST_DEFINE_OPERATOR_ARCHETYPE(%, modable) | |
319 | ||
320 | // As is, these are useless because of the return type. | |
321 | // Need to invent a better way... | |
322 | #define BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(OP, NAME) \ | |
323 | template <class Return, class Base = null_archetype<> > \ | |
324 | class NAME##_first_archetype : public Base { \ | |
325 | public: \ | |
326 | NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \ | |
327 | }; \ | |
328 | \ | |
329 | template <class Return, class Base = null_archetype<> > \ | |
330 | class NAME##_second_archetype : public Base { \ | |
331 | public: \ | |
332 | NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \ | |
333 | }; \ | |
334 | \ | |
335 | template <class Return, class BaseFirst, class BaseSecond> \ | |
336 | Return \ | |
337 | operator OP (const NAME##_first_archetype<Return, BaseFirst>&, \ | |
338 | const NAME##_second_archetype<Return, BaseSecond>&) \ | |
339 | { \ | |
340 | return Return(static_object<detail::dummy_constructor>::get()); \ | |
341 | } | |
342 | ||
343 | BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(+, plus_op) | |
344 | BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(*, time_op) | |
345 | BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(/, divide_op) | |
346 | BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(-, subtract_op) | |
347 | BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(%, mod_op) | |
348 | ||
349 | //=========================================================================== | |
350 | // Function Object Archetype Classes | |
351 | ||
352 | template <class Return> | |
353 | class generator_archetype { | |
354 | public: | |
355 | const Return& operator()() { | |
356 | return static_object<Return>::get(); | |
357 | } | |
358 | }; | |
359 | ||
360 | class void_generator_archetype { | |
361 | public: | |
362 | void operator()() { } | |
363 | }; | |
364 | ||
365 | template <class Arg, class Return> | |
366 | class unary_function_archetype { | |
367 | private: | |
368 | unary_function_archetype() { } | |
369 | public: | |
370 | unary_function_archetype(detail::dummy_constructor) { } | |
371 | const Return& operator()(const Arg&) const { | |
372 | return static_object<Return>::get(); | |
373 | } | |
374 | }; | |
375 | ||
376 | template <class Arg1, class Arg2, class Return> | |
377 | class binary_function_archetype { | |
378 | private: | |
379 | binary_function_archetype() { } | |
380 | public: | |
381 | binary_function_archetype(detail::dummy_constructor) { } | |
382 | const Return& operator()(const Arg1&, const Arg2&) const { | |
383 | return static_object<Return>::get(); | |
384 | } | |
385 | }; | |
386 | ||
387 | template <class Arg> | |
388 | class unary_predicate_archetype { | |
389 | typedef boolean_archetype Return; | |
390 | unary_predicate_archetype() { } | |
391 | public: | |
392 | unary_predicate_archetype(detail::dummy_constructor) { } | |
393 | const Return& operator()(const Arg&) const { | |
394 | return static_object<Return>::get(); | |
395 | } | |
396 | }; | |
397 | ||
398 | template <class Arg1, class Arg2, class Base = null_archetype<> > | |
399 | class binary_predicate_archetype { | |
400 | typedef boolean_archetype Return; | |
401 | binary_predicate_archetype() { } | |
402 | public: | |
403 | binary_predicate_archetype(detail::dummy_constructor) { } | |
404 | const Return& operator()(const Arg1&, const Arg2&) const { | |
405 | return static_object<Return>::get(); | |
406 | } | |
407 | }; | |
408 | ||
409 | //=========================================================================== | |
410 | // Iterator Archetype Classes | |
411 | ||
412 | template <class T, int I = 0> | |
413 | class input_iterator_archetype | |
414 | { | |
415 | private: | |
416 | typedef input_iterator_archetype self; | |
417 | public: | |
418 | typedef std::input_iterator_tag iterator_category; | |
419 | typedef T value_type; | |
420 | struct reference { | |
421 | operator const value_type&() const { return static_object<T>::get(); } | |
422 | }; | |
423 | typedef const T* pointer; | |
424 | typedef std::ptrdiff_t difference_type; | |
425 | self& operator=(const self&) { return *this; } | |
426 | bool operator==(const self&) const { return true; } | |
427 | bool operator!=(const self&) const { return true; } | |
428 | reference operator*() const { return reference(); } | |
429 | self& operator++() { return *this; } | |
430 | self operator++(int) { return *this; } | |
431 | }; | |
432 | ||
433 | template <class T> | |
434 | class input_iterator_archetype_no_proxy | |
435 | { | |
436 | private: | |
437 | typedef input_iterator_archetype_no_proxy self; | |
438 | public: | |
439 | typedef std::input_iterator_tag iterator_category; | |
440 | typedef T value_type; | |
441 | typedef const T& reference; | |
442 | typedef const T* pointer; | |
443 | typedef std::ptrdiff_t difference_type; | |
444 | self& operator=(const self&) { return *this; } | |
445 | bool operator==(const self&) const { return true; } | |
446 | bool operator!=(const self&) const { return true; } | |
447 | reference operator*() const { return static_object<T>::get(); } | |
448 | self& operator++() { return *this; } | |
449 | self operator++(int) { return *this; } | |
450 | }; | |
451 | ||
452 | template <class T> | |
453 | struct output_proxy { | |
454 | output_proxy& operator=(const T&) { return *this; } | |
455 | }; | |
456 | ||
457 | template <class T> | |
458 | class output_iterator_archetype | |
459 | { | |
460 | public: | |
461 | typedef output_iterator_archetype self; | |
462 | public: | |
463 | typedef std::output_iterator_tag iterator_category; | |
464 | typedef output_proxy<T> value_type; | |
465 | typedef output_proxy<T> reference; | |
466 | typedef void pointer; | |
467 | typedef void difference_type; | |
468 | output_iterator_archetype(detail::dummy_constructor) { } | |
469 | output_iterator_archetype(const self&) { } | |
470 | self& operator=(const self&) { return *this; } | |
471 | bool operator==(const self&) const { return true; } | |
472 | bool operator!=(const self&) const { return true; } | |
473 | reference operator*() const { return output_proxy<T>(); } | |
474 | self& operator++() { return *this; } | |
475 | self operator++(int) { return *this; } | |
476 | private: | |
477 | output_iterator_archetype() { } | |
478 | }; | |
479 | ||
480 | template <class T> | |
481 | class input_output_iterator_archetype | |
482 | { | |
483 | private: | |
484 | typedef input_output_iterator_archetype self; | |
485 | struct in_out_tag : public std::input_iterator_tag, public std::output_iterator_tag { }; | |
486 | public: | |
487 | typedef in_out_tag iterator_category; | |
488 | typedef T value_type; | |
489 | struct reference { | |
490 | reference& operator=(const T&) { return *this; } | |
491 | operator value_type() { return static_object<T>::get(); } | |
492 | }; | |
493 | typedef const T* pointer; | |
494 | typedef std::ptrdiff_t difference_type; | |
495 | input_output_iterator_archetype() { } | |
496 | self& operator=(const self&) { return *this; } | |
497 | bool operator==(const self&) const { return true; } | |
498 | bool operator!=(const self&) const { return true; } | |
499 | reference operator*() const { return reference(); } | |
500 | self& operator++() { return *this; } | |
501 | self operator++(int) { return *this; } | |
502 | }; | |
503 | ||
504 | template <class T> | |
505 | class forward_iterator_archetype | |
506 | { | |
507 | public: | |
508 | typedef forward_iterator_archetype self; | |
509 | public: | |
510 | typedef std::forward_iterator_tag iterator_category; | |
511 | typedef T value_type; | |
512 | typedef const T& reference; | |
513 | typedef T const* pointer; | |
514 | typedef std::ptrdiff_t difference_type; | |
515 | forward_iterator_archetype() { } | |
516 | self& operator=(const self&) { return *this; } | |
517 | bool operator==(const self&) const { return true; } | |
518 | bool operator!=(const self&) const { return true; } | |
519 | reference operator*() const { return static_object<T>::get(); } | |
520 | self& operator++() { return *this; } | |
521 | self operator++(int) { return *this; } | |
522 | }; | |
523 | ||
524 | template <class T> | |
525 | class mutable_forward_iterator_archetype | |
526 | { | |
527 | public: | |
528 | typedef mutable_forward_iterator_archetype self; | |
529 | public: | |
530 | typedef std::forward_iterator_tag iterator_category; | |
531 | typedef T value_type; | |
532 | typedef T& reference; | |
533 | typedef T* pointer; | |
534 | typedef std::ptrdiff_t difference_type; | |
535 | mutable_forward_iterator_archetype() { } | |
536 | self& operator=(const self&) { return *this; } | |
537 | bool operator==(const self&) const { return true; } | |
538 | bool operator!=(const self&) const { return true; } | |
539 | reference operator*() const { return static_object<T>::get(); } | |
540 | self& operator++() { return *this; } | |
541 | self operator++(int) { return *this; } | |
542 | }; | |
543 | ||
544 | template <class T> | |
545 | class bidirectional_iterator_archetype | |
546 | { | |
547 | public: | |
548 | typedef bidirectional_iterator_archetype self; | |
549 | public: | |
550 | typedef std::bidirectional_iterator_tag iterator_category; | |
551 | typedef T value_type; | |
552 | typedef const T& reference; | |
553 | typedef T* pointer; | |
554 | typedef std::ptrdiff_t difference_type; | |
555 | bidirectional_iterator_archetype() { } | |
556 | self& operator=(const self&) { return *this; } | |
557 | bool operator==(const self&) const { return true; } | |
558 | bool operator!=(const self&) const { return true; } | |
559 | reference operator*() const { return static_object<T>::get(); } | |
560 | self& operator++() { return *this; } | |
561 | self operator++(int) { return *this; } | |
562 | self& operator--() { return *this; } | |
563 | self operator--(int) { return *this; } | |
564 | }; | |
565 | ||
566 | template <class T> | |
567 | class mutable_bidirectional_iterator_archetype | |
568 | { | |
569 | public: | |
570 | typedef mutable_bidirectional_iterator_archetype self; | |
571 | public: | |
572 | typedef std::bidirectional_iterator_tag iterator_category; | |
573 | typedef T value_type; | |
574 | typedef T& reference; | |
575 | typedef T* pointer; | |
576 | typedef std::ptrdiff_t difference_type; | |
577 | mutable_bidirectional_iterator_archetype() { } | |
578 | self& operator=(const self&) { return *this; } | |
579 | bool operator==(const self&) const { return true; } | |
580 | bool operator!=(const self&) const { return true; } | |
581 | reference operator*() const { return static_object<T>::get(); } | |
582 | self& operator++() { return *this; } | |
583 | self operator++(int) { return *this; } | |
584 | self& operator--() { return *this; } | |
585 | self operator--(int) { return *this; } | |
586 | }; | |
587 | ||
588 | template <class T> | |
589 | class random_access_iterator_archetype | |
590 | { | |
591 | public: | |
592 | typedef random_access_iterator_archetype self; | |
593 | public: | |
594 | typedef std::random_access_iterator_tag iterator_category; | |
595 | typedef T value_type; | |
596 | typedef const T& reference; | |
597 | typedef T* pointer; | |
598 | typedef std::ptrdiff_t difference_type; | |
599 | random_access_iterator_archetype() { } | |
600 | self& operator=(const self&) { return *this; } | |
601 | bool operator==(const self&) const { return true; } | |
602 | bool operator!=(const self&) const { return true; } | |
603 | reference operator*() const { return static_object<T>::get(); } | |
604 | self& operator++() { return *this; } | |
605 | self operator++(int) { return *this; } | |
606 | self& operator--() { return *this; } | |
607 | self operator--(int) { return *this; } | |
608 | reference operator[](difference_type) const | |
609 | { return static_object<T>::get(); } | |
610 | self& operator+=(difference_type) { return *this; } | |
611 | self& operator-=(difference_type) { return *this; } | |
612 | difference_type operator-(const self&) const | |
613 | { return difference_type(); } | |
614 | self operator+(difference_type) const { return *this; } | |
615 | self operator-(difference_type) const { return *this; } | |
616 | bool operator<(const self&) const { return true; } | |
617 | bool operator<=(const self&) const { return true; } | |
618 | bool operator>(const self&) const { return true; } | |
619 | bool operator>=(const self&) const { return true; } | |
620 | }; | |
621 | template <class T> | |
622 | random_access_iterator_archetype<T> | |
623 | operator+(typename random_access_iterator_archetype<T>::difference_type, | |
624 | const random_access_iterator_archetype<T>& x) | |
625 | { return x; } | |
626 | ||
627 | ||
628 | template <class T> | |
629 | class mutable_random_access_iterator_archetype | |
630 | { | |
631 | public: | |
632 | typedef mutable_random_access_iterator_archetype self; | |
633 | public: | |
634 | typedef std::random_access_iterator_tag iterator_category; | |
635 | typedef T value_type; | |
636 | typedef T& reference; | |
637 | typedef T* pointer; | |
638 | typedef std::ptrdiff_t difference_type; | |
639 | mutable_random_access_iterator_archetype() { } | |
640 | self& operator=(const self&) { return *this; } | |
641 | bool operator==(const self&) const { return true; } | |
642 | bool operator!=(const self&) const { return true; } | |
643 | reference operator*() const { return static_object<T>::get(); } | |
644 | self& operator++() { return *this; } | |
645 | self operator++(int) { return *this; } | |
646 | self& operator--() { return *this; } | |
647 | self operator--(int) { return *this; } | |
648 | reference operator[](difference_type) const | |
649 | { return static_object<T>::get(); } | |
650 | self& operator+=(difference_type) { return *this; } | |
651 | self& operator-=(difference_type) { return *this; } | |
652 | difference_type operator-(const self&) const | |
653 | { return difference_type(); } | |
654 | self operator+(difference_type) const { return *this; } | |
655 | self operator-(difference_type) const { return *this; } | |
656 | bool operator<(const self&) const { return true; } | |
657 | bool operator<=(const self&) const { return true; } | |
658 | bool operator>(const self&) const { return true; } | |
659 | bool operator>=(const self&) const { return true; } | |
660 | }; | |
661 | template <class T> | |
662 | mutable_random_access_iterator_archetype<T> | |
663 | operator+ | |
664 | (typename mutable_random_access_iterator_archetype<T>::difference_type, | |
665 | const mutable_random_access_iterator_archetype<T>& x) | |
666 | { return x; } | |
667 | ||
668 | } // namespace boost | |
669 | ||
670 | #endif // BOOST_CONCEPT_ARCHETYPES_H |