← Back to branch summary

~ubuntu-branches/ubuntu/warty/aqsis/warty

« back to all changes in this revision

Viewing changes to boost/boost/concept_archetype.hpp

  • Committer: Bazaar Package Importer
  • Author(s): LaMont Jones
  • Date: 2004-08-24 07:25:04 UTC
  • Revision ID: james.westby@ubuntu.com-20040824072504-zf993vnevvisdsvb
Tags: upstream-0.9.1
Import upstream version 0.9.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
boost/boost/concept_archetype.hpp
 
1
//
 
2
// (C) Copyright Jeremy Siek 2000. Permission to copy, use, modify,
 
3
// sell and distribute this software is granted provided this
 
4
// copyright notice appears in all copies. This software is provided
 
5
// "as is" without express or implied warranty, and with no claim as
 
6
// to its suitability for any purpose.
 
7
//
 
8
// Revision History:
 
9
//
 
10
//   17 July  2001: Added const to some member functions. (Jeremy Siek) 
 
11
//   05 May   2001: Removed static dummy_cons object. (Jeremy Siek)
 
12
 
 
13
// See http://www.boost.org/libs/concept_check for documentation.
 
14
 
 
15
#ifndef BOOST_CONCEPT_ARCHETYPES_HPP
 
16
#define BOOST_CONCEPT_ARCHETYPES_HPP
 
17
 
 
18
#include <boost/config.hpp>
 
19
#include <boost/iterator.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
  public:
 
56
    static T& get() {
 
57
     static char d[sizeof(T)];
 
58
      return *reinterpret_cast<T*>(d);
 
59
    }
 
60
  };
 
61
 
 
62
  template <class Base = null_archetype<> >
 
63
  class default_constructible_archetype : public Base {
 
64
  public:
 
65
    default_constructible_archetype() 
 
66
      : Base(static_object<detail::dummy_constructor>::get()) { }
 
67
    default_constructible_archetype(detail::dummy_constructor x) : Base(x) { }
 
68
  };
 
69
 
 
70
  template <class Base = null_archetype<> >
 
71
  class assignable_archetype : public Base {
 
72
    assignable_archetype() { }
 
73
    assignable_archetype(const assignable_archetype&) { }
 
74
  public:
 
75
    assignable_archetype& operator=(const assignable_archetype&) {
 
76
      return *this;
 
77
    }
 
78
    assignable_archetype(detail::dummy_constructor x) : Base(x) { }
 
79
  };
 
80
 
 
81
  template <class Base = null_archetype<> >
 
82
  class copy_constructible_archetype : public Base {
 
83
  public:
 
84
    copy_constructible_archetype() 
 
85
      : Base(static_object<detail::dummy_constructor>::get()) { }
 
86
    copy_constructible_archetype(const copy_constructible_archetype&)
 
87
      : Base(static_object<detail::dummy_constructor>::get()) { }
 
88
    copy_constructible_archetype(detail::dummy_constructor x) : Base(x) { }
 
89
  };
 
90
 
 
91
  template <class Base = null_archetype<> >
 
92
  class sgi_assignable_archetype : public Base {
 
93
  public:
 
94
    sgi_assignable_archetype(const sgi_assignable_archetype&)
 
95
      : Base(static_object<detail::dummy_constructor>::get()) { }
 
96
    sgi_assignable_archetype& operator=(const sgi_assignable_archetype&) {
 
97
      return *this;
 
98
    }
 
99
    sgi_assignable_archetype(const detail::dummy_constructor& x) : Base(x) { }
 
100
  };
 
101
 
 
102
  struct default_archetype_base {
 
103
    default_archetype_base(detail::dummy_constructor) { }
 
104
  };
 
105
 
 
106
  // Careful, don't use same type for T and Base. That results in the
 
107
  // conversion operator being invalid.  Since T is often
 
108
  // null_archetype, can't use null_archetype for Base.
 
109
  template <class T, class Base = default_archetype_base>
 
110
  class convertible_to_archetype : public Base {
 
111
  private:
 
112
    convertible_to_archetype() { }
 
113
    convertible_to_archetype(const convertible_to_archetype& ) { }
 
114
    convertible_to_archetype& operator=(const convertible_to_archetype&)
 
115
      { return *this; }
 
116
  public:
 
117
    convertible_to_archetype(detail::dummy_constructor x) : Base(x) { }
 
118
    operator const T&() const { return static_object<T>::get(); }
 
119
  };
 
120
 
 
121
  template <class T, class Base = default_archetype_base>
 
122
  class convertible_from_archetype : public Base {
 
123
  private:
 
124
    convertible_from_archetype() { }
 
125
    convertible_from_archetype(const convertible_from_archetype& ) { }
 
126
    convertible_from_archetype& operator=(const convertible_from_archetype&)
 
127
      { return *this; }
 
128
  public:
 
129
    convertible_from_archetype(detail::dummy_constructor x) : Base(x) { }
 
130
    convertible_from_archetype(const T&) { }
 
131
    convertible_from_archetype& operator=(const T&)
 
132
      { return *this; }
 
133
  };
 
134
 
 
135
  class boolean_archetype {
 
136
  public:
 
137
    boolean_archetype(const boolean_archetype&) { }
 
138
    operator bool() const { return true; }
 
139
    boolean_archetype(detail::dummy_constructor) { }
 
140
  private:
 
141
    boolean_archetype() { }
 
142
    boolean_archetype& operator=(const boolean_archetype&) { return *this; }
 
143
  };
 
144
  
 
145
  template <class Base = null_archetype<> >
 
146
  class equality_comparable_archetype : public Base {
 
147
  public:
 
148
    equality_comparable_archetype(detail::dummy_constructor x) : Base(x) { }
 
149
  };
 
150
  template <class Base>
 
151
  boolean_archetype
 
152
  operator==(const equality_comparable_archetype<Base>&,
 
153
             const equality_comparable_archetype<Base>&) 
 
154
  { 
 
155
    return boolean_archetype(static_object<detail::dummy_constructor>::get());
 
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
 
 
165
 
 
166
  template <class Base = null_archetype<> >
 
167
  class equality_comparable2_first_archetype : public Base {
 
168
  public:
 
169
    equality_comparable2_first_archetype(detail::dummy_constructor x) 
 
170
      : Base(x) { }
 
171
  };
 
172
  template <class Base = null_archetype<> >
 
173
  class equality_comparable2_second_archetype : public Base {
 
174
  public:
 
175
    equality_comparable2_second_archetype(detail::dummy_constructor x) 
 
176
      : Base(x) { }
 
177
  };
 
178
  template <class Base1, class Base2>
 
179
  boolean_archetype
 
180
  operator==(const equality_comparable2_first_archetype<Base1>&,
 
181
             const equality_comparable2_second_archetype<Base2>&) 
 
182
  {
 
183
    return boolean_archetype(static_object<detail::dummy_constructor>::get());
 
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
 
 
193
 
 
194
  template <class Base = null_archetype<> >
 
195
  class less_than_comparable_archetype : public Base {
 
196
  public:
 
197
    less_than_comparable_archetype(detail::dummy_constructor x) : Base(x) { }
 
198
  };
 
199
  template <class Base>
 
200
  boolean_archetype
 
201
  operator<(const less_than_comparable_archetype<Base>&,
 
202
            const less_than_comparable_archetype<Base>&)
 
203
  {
 
204
    return boolean_archetype(static_object<detail::dummy_constructor>::get());
 
205
  }
 
206
 
 
207
 
 
208
 
 
209
  template <class Base = null_archetype<> >
 
210
  class comparable_archetype : public Base {
 
211
  public:
 
212
    comparable_archetype(detail::dummy_constructor x) : Base(x) { }
 
213
  };
 
214
  template <class Base>
 
215
  boolean_archetype
 
216
  operator<(const comparable_archetype<Base>&,
 
217
            const comparable_archetype<Base>&)
 
218
  {
 
219
    return boolean_archetype(static_object<detail::dummy_constructor>::get());
 
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
 
 
243
 
 
244
  // The purpose of the optags is so that one can specify
 
245
  // exactly which types the operator< is defined between.
 
246
  // This is useful for allowing the operations:
 
247
  //
 
248
  // A a; B b;
 
249
  // a < b
 
250
  // b < a
 
251
  //
 
252
  // without also allowing the combinations:
 
253
  //
 
254
  // a < a
 
255
  // b < b
 
256
  //
 
257
  struct optag1 { };
 
258
  struct optag2 { };
 
259
  struct optag3 { };
 
260
 
 
261
#define BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(OP, NAME) \
 
262
  template <class Base = null_archetype<>, class Tag = optag1 > \
 
263
  class NAME##_first_archetype : public Base { \
 
264
  public: \
 
265
    NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \
 
266
  }; \
 
267
  \
 
268
  template <class Base = null_archetype<>, class Tag = optag1 > \
 
269
  class NAME##_second_archetype : public Base { \
 
270
  public: \
 
271
    NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \
 
272
  }; \
 
273
  \
 
274
  template <class BaseFirst, class BaseSecond, class Tag> \
 
275
  boolean_archetype \
 
276
  operator OP (const NAME##_first_archetype<BaseFirst, Tag>&, \
 
277
               const NAME##_second_archetype<BaseSecond, Tag>&) \
 
278
  { \
 
279
   return boolean_archetype(static_object<detail::dummy_constructor>::get()); \
 
280
  }
 
281
 
 
282
  BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(==, equal_op)
 
283
  BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(!=, not_equal_op)
 
284
  BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<, less_than_op)
 
285
  BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(<=, less_equal_op)
 
286
  BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>, greater_than_op)
 
287
  BOOST_DEFINE_BINARY_PREDICATE_ARCHETYPE(>=, greater_equal_op)
 
288
 
 
289
#define BOOST_DEFINE_OPERATOR_ARCHETYPE(OP, NAME) \
 
290
  template <class Base = null_archetype<> > \
 
291
  class NAME##_archetype : public Base { \
 
292
  public: \
 
293
    NAME##_archetype(detail::dummy_constructor x) : Base(x) { } \
 
294
    NAME##_archetype(const NAME##_archetype&)  \
 
295
      : Base(static_object<detail::dummy_constructor>::get()) { } \
 
296
    NAME##_archetype& operator=(const NAME##_archetype&) { return *this; } \
 
297
  }; \
 
298
  template <class Base> \
 
299
  NAME##_archetype<Base> \
 
300
  operator OP (const NAME##_archetype<Base>&,\
 
301
               const NAME##_archetype<Base>&)  \
 
302
  { \
 
303
    return \
 
304
     NAME##_archetype<Base>(static_object<detail::dummy_constructor>::get()); \
 
305
  }
 
306
 
 
307
  BOOST_DEFINE_OPERATOR_ARCHETYPE(+, addable)
 
308
  BOOST_DEFINE_OPERATOR_ARCHETYPE(-, subtractable)
 
309
  BOOST_DEFINE_OPERATOR_ARCHETYPE(*, multipliable)
 
310
  BOOST_DEFINE_OPERATOR_ARCHETYPE(/, dividable)
 
311
  BOOST_DEFINE_OPERATOR_ARCHETYPE(%, modable)
 
312
 
 
313
  // As is, these are useless because of the return type.
 
314
  // Need to invent a better way...
 
315
#define BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(OP, NAME) \
 
316
  template <class Return, class Base = null_archetype<> > \
 
317
  class NAME##_first_archetype : public Base { \
 
318
  public: \
 
319
    NAME##_first_archetype(detail::dummy_constructor x) : Base(x) { } \
 
320
  }; \
 
321
  \
 
322
  template <class Return, class Base = null_archetype<> > \
 
323
  class NAME##_second_archetype : public Base { \
 
324
  public: \
 
325
    NAME##_second_archetype(detail::dummy_constructor x) : Base(x) { } \
 
326
  }; \
 
327
  \
 
328
  template <class Return, class BaseFirst, class BaseSecond> \
 
329
  Return \
 
330
  operator OP (const NAME##_first_archetype<Return, BaseFirst>&, \
 
331
               const NAME##_second_archetype<Return, BaseSecond>&) \
 
332
  { \
 
333
    return Return(static_object<detail::dummy_constructor>::get()); \
 
334
  }
 
335
 
 
336
  BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(+, plus_op)
 
337
  BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(*, time_op)
 
338
  BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(/, divide_op)
 
339
  BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(-, subtract_op)
 
340
  BOOST_DEFINE_BINARY_OPERATOR_ARCHETYPE(%, mod_op)
 
341
 
 
342
  //===========================================================================
 
343
  // Function Object Archetype Classes
 
344
 
 
345
  template <class Return>
 
346
  class generator_archetype {
 
347
  public:
 
348
    const Return& operator()() {
 
349
      return static_object<Return>::get(); 
 
350
    }
 
351
  };
 
352
 
 
353
  class void_generator_archetype {
 
354
  public:
 
355
    void operator()() { }
 
356
  };
 
357
 
 
358
  template <class Arg, class Return>
 
359
  class unary_function_archetype {
 
360
  private:
 
361
    unary_function_archetype() { }
 
362
  public:
 
363
    unary_function_archetype(detail::dummy_constructor) { }
 
364
    const Return& operator()(const Arg&) const {
 
365
      return static_object<Return>::get(); 
 
366
    }
 
367
  };
 
368
 
 
369
  template <class Arg1, class Arg2, class Return>
 
370
  class binary_function_archetype {
 
371
  private:
 
372
    binary_function_archetype() { }
 
373
  public:
 
374
    binary_function_archetype(detail::dummy_constructor) { }
 
375
    const Return& operator()(const Arg1&, const Arg2&) const {
 
376
      return static_object<Return>::get(); 
 
377
    }
 
378
  };
 
379
 
 
380
  template <class Arg>
 
381
  class unary_predicate_archetype {
 
382
    typedef boolean_archetype Return;
 
383
    unary_predicate_archetype() { }
 
384
  public:
 
385
    unary_predicate_archetype(detail::dummy_constructor) { }
 
386
    const Return& operator()(const Arg&) const {
 
387
      return static_object<Return>::get(); 
 
388
    }
 
389
  };
 
390
 
 
391
  template <class Arg1, class Arg2, class Base = null_archetype<> >
 
392
  class binary_predicate_archetype {
 
393
    typedef boolean_archetype Return;
 
394
    binary_predicate_archetype() { }
 
395
  public:
 
396
    binary_predicate_archetype(detail::dummy_constructor) { }
 
397
    const Return& operator()(const Arg1&, const Arg2&) const {
 
398
      return static_object<Return>::get(); 
 
399
    }
 
400
  };
 
401
 
 
402
  //===========================================================================
 
403
  // Iterator Archetype Classes
 
404
 
 
405
  template <class T>
 
406
  struct input_proxy {
 
407
    operator const T&() { return static_object<T>::get(); }
 
408
  };
 
409
  template <class T>
 
410
  class trivial_iterator_archetype
 
411
  {
 
412
    typedef trivial_iterator_archetype self;
 
413
  public:
 
414
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
415
    typedef T value_type;
 
416
    typedef void reference;
 
417
    typedef void pointer;
 
418
    typedef void difference_type;
 
419
    typedef void iterator_category;
 
420
#endif
 
421
    trivial_iterator_archetype() { }
 
422
    self& operator=(const self&) { return *this;  }
 
423
    bool operator==(const self&) const { return true; }
 
424
    bool operator!=(const self&) const { return true; }
 
425
    input_proxy<T> operator*() const { return input_proxy<T>(); }
 
426
  };
 
427
} // namespace boost
 
428
 
 
429
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
 
430
namespace std {
 
431
  template <class T>
 
432
  struct iterator_traits< boost::trivial_iterator_archetype<T> >
 
433
  {
 
434
    typedef T value_type;
 
435
  };
 
436
}
 
437
#endif
 
438
 
 
439
namespace boost {
 
440
  template <class T>
 
441
  struct input_output_proxy {
 
442
    input_output_proxy<T>& operator=(const T&) { return *this; }
 
443
    operator const T&() { return static_object<T>::get(); }
 
444
  };
 
445
  template <class T>
 
446
  class mutable_trivial_iterator_archetype
 
447
  {
 
448
    typedef mutable_trivial_iterator_archetype self;
 
449
  public:
 
450
#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
451
    typedef T value_type;
 
452
    typedef void reference;
 
453
    typedef void pointer;
 
454
    typedef void difference_type;
 
455
    typedef void iterator_category;
 
456
#endif
 
457
    mutable_trivial_iterator_archetype() { }
 
458
    self& operator=(const self&) { return *this;  }
 
459
    bool operator==(const self&) const { return true; }
 
460
    bool operator!=(const self&) const { return true; }
 
461
    input_output_proxy<T> operator*() const { return input_output_proxy<T>(); }
 
462
  };
 
463
} // namespace boost
 
464
 
 
465
#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_NO_STD_ITERATOR_TRAITS)
 
466
namespace std {
 
467
  template <class T>
 
468
  struct iterator_traits< boost::mutable_trivial_iterator_archetype<T> >
 
469
  {
 
470
    typedef T value_type;
 
471
  };
 
472
}
 
473
#endif
 
474
 
 
475
namespace boost {
 
476
 
 
477
  template <class T>
 
478
  class input_iterator_archetype
 
479
  {
 
480
  public:
 
481
    typedef input_iterator_archetype self;
 
482
  public:
 
483
    typedef std::input_iterator_tag iterator_category;
 
484
    typedef T value_type;
 
485
    typedef const T& reference;
 
486
    typedef const T* pointer;
 
487
    typedef std::ptrdiff_t difference_type;
 
488
    input_iterator_archetype() { }
 
489
    self& operator=(const self&) { return *this;  }
 
490
    bool operator==(const self&) const { return true; }
 
491
    bool operator!=(const self&) const { return true; }
 
492
    reference operator*() const { return static_object<T>::get(); }
 
493
    self& operator++() { return *this; }
 
494
    self operator++(int) { return *this; }
 
495
  };
 
496
 
 
497
 template <class T>
 
498
  struct output_proxy {
 
499
    output_proxy& operator=(const T&) { return *this; }
 
500
  };
 
501
 
 
502
  template <class T>
 
503
  class output_iterator_archetype
 
504
  {
 
505
  public:
 
506
    typedef output_iterator_archetype self;
 
507
  public:
 
508
    typedef std::output_iterator_tag iterator_category;
 
509
    typedef output_proxy<T> value_type;
 
510
    typedef output_proxy<T> reference;
 
511
    typedef void pointer;
 
512
    typedef void difference_type;
 
513
    output_iterator_archetype(detail::dummy_constructor) { }
 
514
    output_iterator_archetype(const self&) { }
 
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 output_proxy<T>(); }
 
519
    self& operator++() { return *this; }
 
520
    self operator++(int) { return *this; }
 
521
  private:
 
522
    output_iterator_archetype() { }
 
523
  };
 
524
 
 
525
  template <class T>
 
526
  class forward_iterator_archetype
 
527
  {
 
528
  public:
 
529
    typedef forward_iterator_archetype self;
 
530
  public:
 
531
    typedef std::forward_iterator_tag iterator_category;
 
532
    typedef T value_type;
 
533
    typedef const T& reference;
 
534
    typedef T* pointer;
 
535
    typedef std::ptrdiff_t difference_type;
 
536
    forward_iterator_archetype() { }
 
537
    self& operator=(const self&) { return *this;  }
 
538
    bool operator==(const self&) const { return true; }
 
539
    bool operator!=(const self&) const { return true; }
 
540
    reference operator*() const { return static_object<T>::get(); }
 
541
    self& operator++() { return *this; }
 
542
    self operator++(int) { return *this; }
 
543
  };
 
544
 
 
545
  template <class T>
 
546
  class mutable_forward_iterator_archetype
 
547
  {
 
548
  public:
 
549
    typedef mutable_forward_iterator_archetype self;
 
550
  public:
 
551
    typedef std::forward_iterator_tag iterator_category;
 
552
    typedef T value_type;
 
553
    typedef T& reference;
 
554
    typedef T* pointer;
 
555
    typedef std::ptrdiff_t difference_type;
 
556
    mutable_forward_iterator_archetype() { }
 
557
    self& operator=(const self&) { return *this;  }
 
558
    bool operator==(const self&) const { return true; }
 
559
    bool operator!=(const self&) const { return true; }
 
560
    reference operator*() const { return static_object<T>::get(); }
 
561
    self& operator++() { return *this; }
 
562
    self operator++(int) { return *this; }
 
563
  };
 
564
 
 
565
  template <class T>
 
566
  class bidirectional_iterator_archetype
 
567
  {
 
568
  public:
 
569
    typedef bidirectional_iterator_archetype self;
 
570
  public:
 
571
    typedef std::bidirectional_iterator_tag iterator_category;
 
572
    typedef T value_type;
 
573
    typedef const T& reference;
 
574
    typedef T* pointer;
 
575
    typedef std::ptrdiff_t difference_type;
 
576
    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 mutable_bidirectional_iterator_archetype
 
589
  {
 
590
  public:
 
591
    typedef mutable_bidirectional_iterator_archetype self;
 
592
  public:
 
593
    typedef std::bidirectional_iterator_tag iterator_category;
 
594
    typedef T value_type;
 
595
    typedef T& reference;
 
596
    typedef T* pointer;
 
597
    typedef std::ptrdiff_t difference_type;
 
598
    mutable_bidirectional_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
  };
 
608
 
 
609
  template <class T>
 
610
  class random_access_iterator_archetype
 
611
  {
 
612
  public:
 
613
    typedef random_access_iterator_archetype self;
 
614
  public:
 
615
    typedef std::random_access_iterator_tag iterator_category;
 
616
    typedef T value_type;
 
617
    typedef const T& reference;
 
618
    typedef T* pointer;
 
619
    typedef std::ptrdiff_t difference_type;
 
620
    random_access_iterator_archetype() { }
 
621
    self& operator=(const self&) { return *this;  }
 
622
    bool operator==(const self&) const { return true; }
 
623
    bool operator!=(const self&) const { return true; }
 
624
    reference operator*() const { return static_object<T>::get(); }
 
625
    self& operator++() { return *this; }
 
626
    self operator++(int) { return *this; }
 
627
    self& operator--() { return *this; }
 
628
    self operator--(int) { return *this; }
 
629
    reference operator[](difference_type) const
 
630
      { return static_object<T>::get(); }
 
631
    self& operator+=(difference_type) { return *this; }
 
632
    self& operator-=(difference_type) { return *this; }
 
633
    difference_type operator-(const self&) const
 
634
      { return difference_type(); }
 
635
    self operator+(difference_type) const { return *this; }
 
636
    self operator-(difference_type) const { return *this; }
 
637
    bool operator<(const self&) const { return true; }
 
638
    bool operator<=(const self&) const { return true; }
 
639
    bool operator>(const self&) const { return true; }
 
640
    bool operator>=(const self&) const { return true; }
 
641
  };
 
642
  template <class T>
 
643
  random_access_iterator_archetype<T> 
 
644
  operator+(typename random_access_iterator_archetype<T>::difference_type, 
 
645
            const random_access_iterator_archetype<T>& x) 
 
646
    { return x; }
 
647
 
 
648
 
 
649
  template <class T>
 
650
  class mutable_random_access_iterator_archetype
 
651
  {
 
652
  public:
 
653
    typedef mutable_random_access_iterator_archetype self;
 
654
  public:
 
655
    typedef std::random_access_iterator_tag iterator_category;
 
656
    typedef T value_type;
 
657
    typedef T& reference;
 
658
    typedef T* pointer;
 
659
    typedef std::ptrdiff_t difference_type;
 
660
    mutable_random_access_iterator_archetype() { }
 
661
    self& operator=(const self&) { return *this;  }
 
662
    bool operator==(const self&) const { return true; }
 
663
    bool operator!=(const self&) const { return true; }
 
664
    reference operator*() const { return static_object<T>::get(); }
 
665
    self& operator++() { return *this; }
 
666
    self operator++(int) { return *this; }
 
667
    self& operator--() { return *this; }
 
668
    self operator--(int) { return *this; }
 
669
    reference operator[](difference_type) const
 
670
      { return static_object<T>::get(); }
 
671
    self& operator+=(difference_type) { return *this; }
 
672
    self& operator-=(difference_type) { return *this; }
 
673
    difference_type operator-(const self&) const
 
674
      { return difference_type(); }
 
675
    self operator+(difference_type) const { return *this; }
 
676
    self operator-(difference_type) const { return *this; }
 
677
    bool operator<(const self&) const { return true; }
 
678
    bool operator<=(const self&) const { return true; }
 
679
    bool operator>(const self&) const { return true; }
 
680
    bool operator>=(const self&) const { return true; }
 
681
  };
 
682
  template <class T>
 
683
  mutable_random_access_iterator_archetype<T> 
 
684
  operator+
 
685
    (typename mutable_random_access_iterator_archetype<T>::difference_type, 
 
686
     const mutable_random_access_iterator_archetype<T>& x) 
 
687
    { return x; }
 
688
 
 
689
} // namespace boost
 
690
 
 
691
#endif // BOOST_CONCEPT_ARCHETYPES_H