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