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