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/config/workaround.hpp>
19#include <functional>
20#include <iterator> // iterator tags
21#include <cstddef> // std::ptrdiff_t
22
23namespace 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 {
60#if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564))
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
671