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