boost/boost/operators.hpp

   1 //  Boost operators.hpp header file  ----------------------------------------//
   2
   3 //  (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
   4 //  Distributed under the Boost Software License, Version 1.0. (See
   5 //  accompanying file LICENSE_1_0.txt or copy at
   6 //  http://www.boost.org/LICENSE_1_0.txt)
   7
   8 //  See http://www.boost.org/libs/utility/operators.htm for documentation.
   9
  10 //  Revision History
  11 //  21 Oct 02 Modified implementation of operators to allow compilers with a
  12 //            correct named return value optimization (NRVO) to produce optimal
  13 //            code.  (Daniel Frey)
  14 //  02 Dec 01 Bug fixed in random_access_iteratable.  (Helmut Zeisel)
  15 //  28 Sep 01 Factored out iterator operator groups.  (Daryle Walker)
  16 //  27 Aug 01 'left' form for non commutative operators added;
  17 //            additional classes for groups of related operators added;
  18 //            workaround for empty base class optimization
  19 //            bug of GCC 3.0 (Helmut Zeisel)
  20 //  25 Jun 01 output_iterator_helper changes: removed default template
  21 //            parameters, added support for self-proxying, additional
  22 //            documentation and tests (Aleksey Gurtovoy)
  23 //  29 May 01 Added operator classes for << and >>.  Added input and output
  24 //            iterator helper classes.  Added classes to connect equality and
  25 //            relational operators.  Added classes for groups of related
  26 //            operators.  Reimplemented example operator and iterator helper
  27 //            classes in terms of the new groups.  (Daryle Walker, with help
  28 //            from Alexy Gurtovoy)
  29 //  11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
  30 //            supplied arguments from actually being used (Dave Abrahams)
  31 //  04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
  32 //            refactoring of compiler workarounds, additional documentation
  33 //            (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
  34 //            Dave Abrahams)
  35 //  28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
  36 //            Jeremy Siek (Dave Abrahams)
  37 //  20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
  38 //            (Mark Rodgers)
  39 //  20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
  40 //  10 Jun 00 Support for the base class chaining technique was added
  41 //            (Aleksey Gurtovoy). See documentation and the comments below
  42 //            for the details.
  43 //  12 Dec 99 Initial version with iterator operators (Jeremy Siek)
  44 //  18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
  45 //            specializations of dividable, subtractable, modable (Ed Brey)
  46 //  17 Nov 99 Add comments (Beman Dawes)
  47 //            Remove unnecessary specialization of operators<> (Ed Brey)
  48 //  15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
  49 //            operators.(Beman Dawes)
  50 //  12 Nov 99 Add operators templates (Ed Brey)
  51 //  11 Nov 99 Add single template parameter version for compilers without
  52 //            partial specialization (Beman Dawes)
  53 //  10 Nov 99 Initial version
  54
  55 // 10 Jun 00:
  56 // An additional optional template parameter was added to most of
  57 // operator templates to support the base class chaining technique (see
  58 // documentation for the details). Unfortunately, a straightforward
  59 // implementation of this change would have broken compatibility with the
  60 // previous version of the library by making it impossible to use the same
  61 // template name (e.g. 'addable') for both the 1- and 2-argument versions of
  62 // an operator template. This implementation solves the backward-compatibility
  63 // issue at the cost of some simplicity.
  64 //
  65 // One of the complications is an existence of special auxiliary class template
  66 // 'is_chained_base<>' (see 'detail' namespace below), which is used
  67 // to determine whether its template parameter is a library's operator template
  68 // or not. You have to specialize 'is_chained_base<>' for each new
  69 // operator template you add to the library.
  70 //
  71 // However, most of the non-trivial implementation details are hidden behind
  72 // several local macros defined below, and as soon as you understand them,
  73 // you understand the whole library implementation.
  74
  75 #ifndef BOOST_OPERATORS_HPP
  76 #define BOOST_OPERATORS_HPP
  77
  78 #include <boost/config.hpp>
  79 #include <boost/iterator.hpp>
  80 #include <boost/detail/workaround.hpp>
  81
  82 #if defined(__sgi) && !defined(__GNUC__)
  83 #   pragma set woff 1234
  84 #endif
  85
  86 #if defined(BOOST_MSVC)
  87 #   pragma warning( disable : 4284 ) // complaint about return type of
  88 #endif                               // operator-> not begin a UDT
  89
  90 namespace boost {
  91 namespace detail {
  92
  93 // Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
  94 #if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
  95 class empty_base {
  96   bool dummy;
  97 };
  98 #else
  99 class empty_base {};
 100 #endif
 101
 102 } // namespace detail
 103 } // namespace boost
 104
 105 // In this section we supply the xxxx1 and xxxx2 forms of the operator
 106 // templates, which are explicitly targeted at the 1-type-argument and
 107 // 2-type-argument operator forms, respectively. Some compilers get confused
 108 // when inline friend functions are overloaded in namespaces other than the
 109 // global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
 110 // these templates must go in the global namespace.
 111
 112 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 113 namespace boost
 114 {
 115 #endif
 116
 117 //  Basic operator classes (contributed by Dave Abrahams) ------------------//
 118
 119 //  Note that friend functions defined in a class are implicitly inline.
 120 //  See the C++ std, 11.4 [class.friend] paragraph 5
 121
 122 template <class T, class U, class B = ::boost::detail::empty_base>
 123 struct less_than_comparable2 : B
 124 {
 125      friend bool operator<=(const T& x, const U& y) { return !(x > y); }
 126      friend bool operator>=(const T& x, const U& y) { return !(x < y); }
 127      friend bool operator>(const U& x, const T& y)  { return y < x; }
 128      friend bool operator<(const U& x, const T& y)  { return y > x; }
 129      friend bool operator<=(const U& x, const T& y) { return !(y < x); }
 130      friend bool operator>=(const U& x, const T& y) { return !(y > x); }
 131 };
 132
 133 template <class T, class B = ::boost::detail::empty_base>
 134 struct less_than_comparable1 : B
 135 {
 136      friend bool operator>(const T& x, const T& y)  { return y < x; }
 137      friend bool operator<=(const T& x, const T& y) { return !(y < x); }
 138      friend bool operator>=(const T& x, const T& y) { return !(x < y); }
 139 };
 140
 141 template <class T, class U, class B = ::boost::detail::empty_base>
 142 struct equality_comparable2 : B
 143 {
 144      friend bool operator==(const U& y, const T& x) { return x == y; }
 145      friend bool operator!=(const U& y, const T& x) { return !(x == y); }
 146      friend bool operator!=(const T& y, const U& x) { return !(y == x); }
 147 };
 148
 149 template <class T, class B = ::boost::detail::empty_base>
 150 struct equality_comparable1 : B
 151 {
 152      friend bool operator!=(const T& x, const T& y) { return !(x == y); }
 153 };
 154
 155 // A macro which produces "name_2left" from "name".
 156 #define BOOST_OPERATOR2_LEFT(name) name##2##_##left
 157
 158 //  NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
 159
 160 #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 161
 162 // This is the optimal implementation for ISO/ANSI C++,
 163 // but it requires the compiler to implement the NRVO.
 164 // If the compiler has no NRVO, this is the best symmetric
 165 // implementation available.
 166
 167 #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
 168 template <class T, class U, class B = ::boost::detail::empty_base>            \
 169 struct NAME##2 : B                                                            \
 170 {                                                                             \
 171   friend T operator OP( const T& lhs, const U& rhs )                          \
 172     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 173   friend T operator OP( const U& lhs, const T& rhs )                          \
 174     { T nrv( rhs ); nrv OP##= lhs; return nrv; }                              \
 175 };                                                                            \
 176                                                                               \
 177 template <class T, class B = ::boost::detail::empty_base>                     \
 178 struct NAME##1 : B                                                            \
 179 {                                                                             \
 180   friend T operator OP( const T& lhs, const T& rhs )                          \
 181     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 182 };
 183
 184 #define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )           \
 185 template <class T, class U, class B = ::boost::detail::empty_base>  \
 186 struct NAME##2 : B                                                  \
 187 {                                                                   \
 188   friend T operator OP( const T& lhs, const U& rhs )                \
 189     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
 190 };                                                                  \
 191                                                                     \
 192 template <class T, class U, class B = ::boost::detail::empty_base>  \
 193 struct BOOST_OPERATOR2_LEFT(NAME) : B                               \
 194 {                                                                   \
 195   friend T operator OP( const U& lhs, const T& rhs )                \
 196     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
 197 };                                                                  \
 198                                                                     \
 199 template <class T, class B = ::boost::detail::empty_base>           \
 200 struct NAME##1 : B                                                  \
 201 {                                                                   \
 202   friend T operator OP( const T& lhs, const T& rhs )                \
 203     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                    \
 204 };
 205
 206 #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 207
 208 // For compilers without NRVO the following code is optimal, but not
 209 // symmetric!  Note that the implementation of
 210 // BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
 211 // optimization opportunities to the compiler :)
 212
 213 #define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP )                         \
 214 template <class T, class U, class B = ::boost::detail::empty_base>            \
 215 struct NAME##2 : B                                                            \
 216 {                                                                             \
 217   friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
 218   friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; }       \
 219 };                                                                            \
 220                                                                               \
 221 template <class T, class B = ::boost::detail::empty_base>                     \
 222 struct NAME##1 : B                                                            \
 223 {                                                                             \
 224   friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
 225 };
 226
 227 #define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP )               \
 228 template <class T, class U, class B = ::boost::detail::empty_base>      \
 229 struct NAME##2 : B                                                      \
 230 {                                                                       \
 231   friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
 232 };                                                                      \
 233                                                                         \
 234 template <class T, class U, class B = ::boost::detail::empty_base>      \
 235 struct BOOST_OPERATOR2_LEFT(NAME) : B                                   \
 236 {                                                                       \
 237   friend T operator OP( const U& lhs, const T& rhs )                    \
 238     { return T( lhs ) OP##= rhs; }                                      \
 239 };                                                                      \
 240                                                                         \
 241 template <class T, class B = ::boost::detail::empty_base>               \
 242 struct NAME##1 : B                                                      \
 243 {                                                                       \
 244   friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
 245 };
 246
 247 #endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 248
 249 BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
 250 BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
 251 BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
 252 BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
 253 BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
 254 BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
 255 BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
 256 BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
 257
 258 #undef BOOST_BINARY_OPERATOR_COMMUTATIVE
 259 #undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
 260 #undef BOOST_OPERATOR2_LEFT
 261
 262 //  incrementable and decrementable contributed by Jeremy Siek
 263
 264 template <class T, class B = ::boost::detail::empty_base>
 265 struct incrementable : B
 266 {
 267   friend T operator++(T& x, int)
 268   {
 269     incrementable_type nrv(x);
 270     ++x;
 271     return nrv;
 272   }
 273 private: // The use of this typedef works around a Borland bug
 274   typedef T incrementable_type;
 275 };
 276
 277 template <class T, class B = ::boost::detail::empty_base>
 278 struct decrementable : B
 279 {
 280   friend T operator--(T& x, int)
 281   {
 282     decrementable_type nrv(x);
 283     --x;
 284     return nrv;
 285   }
 286 private: // The use of this typedef works around a Borland bug
 287   typedef T decrementable_type;
 288 };
 289
 290 //  Iterator operator classes (contributed by Jeremy Siek) ------------------//
 291
 292 template <class T, class P, class B = ::boost::detail::empty_base>
 293 struct dereferenceable : B
 294 {
 295   P operator->() const
 296   {
 297     return &*static_cast<const T&>(*this);
 298   }
 299 };
 300
 301 template <class T, class I, class R, class B = ::boost::detail::empty_base>
 302 struct indexable : B
 303 {
 304   R operator[](I n) const
 305   {
 306     return *(static_cast<const T&>(*this) + n);
 307   }
 308 };
 309
 310 //  More operator classes (contributed by Daryle Walker) --------------------//
 311 //  (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
 312
 313 #if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 314
 315 #define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
 316 template <class T, class U, class B = ::boost::detail::empty_base>            \
 317 struct NAME##2 : B                                                            \
 318 {                                                                             \
 319   friend T operator OP( const T& lhs, const U& rhs )                          \
 320     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 321 };                                                                            \
 322                                                                               \
 323 template <class T, class B = ::boost::detail::empty_base>                     \
 324 struct NAME##1 : B                                                            \
 325 {                                                                             \
 326   friend T operator OP( const T& lhs, const T& rhs )                          \
 327     { T nrv( lhs ); nrv OP##= rhs; return nrv; }                              \
 328 };
 329
 330 #else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 331
 332 #define BOOST_BINARY_OPERATOR( NAME, OP )                                     \
 333 template <class T, class U, class B = ::boost::detail::empty_base>            \
 334 struct NAME##2 : B                                                            \
 335 {                                                                             \
 336   friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; }       \
 337 };                                                                            \
 338                                                                               \
 339 template <class T, class B = ::boost::detail::empty_base>                     \
 340 struct NAME##1 : B                                                            \
 341 {                                                                             \
 342   friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; }       \
 343 };
 344
 345 #endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
 346
 347 BOOST_BINARY_OPERATOR( left_shiftable, << )
 348 BOOST_BINARY_OPERATOR( right_shiftable, >> )
 349
 350 #undef BOOST_BINARY_OPERATOR
 351
 352 template <class T, class U, class B = ::boost::detail::empty_base>
 353 struct equivalent2 : B
 354 {
 355   friend bool operator==(const T& x, const U& y)
 356   {
 357     return !(x < y) && !(x > y);
 358   }
 359 };
 360
 361 template <class T, class B = ::boost::detail::empty_base>
 362 struct equivalent1 : B
 363 {
 364   friend bool operator==(const T&x, const T&y)
 365   {
 366     return !(x < y) && !(y < x);
 367   }
 368 };
 369
 370 template <class T, class U, class B = ::boost::detail::empty_base>
 371 struct partially_ordered2 : B
 372 {
 373   friend bool operator<=(const T& x, const U& y)
 374     { return (x < y) || (x == y); }
 375   friend bool operator>=(const T& x, const U& y)
 376     { return (x > y) || (x == y); }
 377   friend bool operator>(const U& x, const T& y)
 378     { return y < x; }
 379   friend bool operator<(const U& x, const T& y)
 380     { return y > x; }
 381   friend bool operator<=(const U& x, const T& y)
 382     { return (y > x) || (y == x); }
 383   friend bool operator>=(const U& x, const T& y)
 384     { return (y < x) || (y == x); }
 385 };
 386
 387 template <class T, class B = ::boost::detail::empty_base>
 388 struct partially_ordered1 : B
 389 {
 390   friend bool operator>(const T& x, const T& y)
 391     { return y < x; }
 392   friend bool operator<=(const T& x, const T& y)
 393     { return (x < y) || (x == y); }
 394   friend bool operator>=(const T& x, const T& y)
 395     { return (y < x) || (x == y); }
 396 };
 397
 398 //  Combined operator classes (contributed by Daryle Walker) ----------------//
 399
 400 template <class T, class U, class B = ::boost::detail::empty_base>
 401 struct totally_ordered2
 402     : less_than_comparable2<T, U
 403     , equality_comparable2<T, U, B
 404       > > {};
 405
 406 template <class T, class B = ::boost::detail::empty_base>
 407 struct totally_ordered1
 408     : less_than_comparable1<T
 409     , equality_comparable1<T, B
 410       > > {};
 411
 412 template <class T, class U, class B = ::boost::detail::empty_base>
 413 struct additive2
 414     : addable2<T, U
 415     , subtractable2<T, U, B
 416       > > {};
 417
 418 template <class T, class B = ::boost::detail::empty_base>
 419 struct additive1
 420     : addable1<T
 421     , subtractable1<T, B
 422       > > {};
 423
 424 template <class T, class U, class B = ::boost::detail::empty_base>
 425 struct multiplicative2
 426     : multipliable2<T, U
 427     , dividable2<T, U, B
 428       > > {};
 429
 430 template <class T, class B = ::boost::detail::empty_base>
 431 struct multiplicative1
 432     : multipliable1<T
 433     , dividable1<T, B
 434       > > {};
 435
 436 template <class T, class U, class B = ::boost::detail::empty_base>
 437 struct integer_multiplicative2
 438     : multiplicative2<T, U
 439     , modable2<T, U, B
 440       > > {};
 441
 442 template <class T, class B = ::boost::detail::empty_base>
 443 struct integer_multiplicative1
 444     : multiplicative1<T
 445     , modable1<T, B
 446       > > {};
 447
 448 template <class T, class U, class B = ::boost::detail::empty_base>
 449 struct arithmetic2
 450     : additive2<T, U
 451     , multiplicative2<T, U, B
 452       > > {};
 453
 454 template <class T, class B = ::boost::detail::empty_base>
 455 struct arithmetic1
 456     : additive1<T
 457     , multiplicative1<T, B
 458       > > {};
 459
 460 template <class T, class U, class B = ::boost::detail::empty_base>
 461 struct integer_arithmetic2
 462     : additive2<T, U
 463     , integer_multiplicative2<T, U, B
 464       > > {};
 465
 466 template <class T, class B = ::boost::detail::empty_base>
 467 struct integer_arithmetic1
 468     : additive1<T
 469     , integer_multiplicative1<T, B
 470       > > {};
 471
 472 template <class T, class U, class B = ::boost::detail::empty_base>
 473 struct bitwise2
 474     : xorable2<T, U
 475     , andable2<T, U
 476     , orable2<T, U, B
 477       > > > {};
 478
 479 template <class T, class B = ::boost::detail::empty_base>
 480 struct bitwise1
 481     : xorable1<T
 482     , andable1<T
 483     , orable1<T, B
 484       > > > {};
 485
 486 template <class T, class B = ::boost::detail::empty_base>
 487 struct unit_steppable
 488     : incrementable<T
 489     , decrementable<T, B
 490       > > {};
 491
 492 template <class T, class U, class B = ::boost::detail::empty_base>
 493 struct shiftable2
 494     : left_shiftable2<T, U
 495     , right_shiftable2<T, U, B
 496       > > {};
 497
 498 template <class T, class B = ::boost::detail::empty_base>
 499 struct shiftable1
 500     : left_shiftable1<T
 501     , right_shiftable1<T, B
 502       > > {};
 503
 504 template <class T, class U, class B = ::boost::detail::empty_base>
 505 struct ring_operators2
 506     : additive2<T, U
 507     , subtractable2_left<T, U
 508     , multipliable2<T, U, B
 509       > > > {};
 510
 511 template <class T, class B = ::boost::detail::empty_base>
 512 struct ring_operators1
 513     : additive1<T
 514     , multipliable1<T, B
 515       > > {};
 516
 517 template <class T, class U, class B = ::boost::detail::empty_base>
 518 struct ordered_ring_operators2
 519     : ring_operators2<T, U
 520     , totally_ordered2<T, U, B
 521       > > {};
 522
 523 template <class T, class B = ::boost::detail::empty_base>
 524 struct ordered_ring_operators1
 525     : ring_operators1<T
 526     , totally_ordered1<T, B
 527       > > {};
 528
 529 template <class T, class U, class B = ::boost::detail::empty_base>
 530 struct field_operators2
 531     : ring_operators2<T, U
 532     , dividable2<T, U
 533     , dividable2_left<T, U, B
 534       > > > {};
 535
 536 template <class T, class B = ::boost::detail::empty_base>
 537 struct field_operators1
 538     : ring_operators1<T
 539     , dividable1<T, B
 540       > > {};
 541
 542 template <class T, class U, class B = ::boost::detail::empty_base>
 543 struct ordered_field_operators2
 544     : field_operators2<T, U
 545     , totally_ordered2<T, U, B
 546       > > {};
 547
 548 template <class T, class B = ::boost::detail::empty_base>
 549 struct ordered_field_operators1
 550     : field_operators1<T
 551     , totally_ordered1<T, B
 552       > > {};
 553
 554 template <class T, class U, class B = ::boost::detail::empty_base>
 555 struct euclidian_ring_operators2
 556     : ring_operators2<T, U
 557     , dividable2<T, U
 558     , dividable2_left<T, U
 559     , modable2<T, U
 560     , modable2_left<T, U, B
 561       > > > > > {};
 562
 563 template <class T, class B = ::boost::detail::empty_base>
 564 struct euclidian_ring_operators1
 565     : ring_operators1<T
 566     , dividable1<T
 567     , modable1<T, B
 568       > > > {};
 569
 570 template <class T, class U, class B = ::boost::detail::empty_base>
 571 struct ordered_euclidian_ring_operators2
 572     : totally_ordered2<T, U
 573     , euclidian_ring_operators2<T, U, B
 574       > > {};
 575
 576 template <class T, class B = ::boost::detail::empty_base>
 577 struct ordered_euclidian_ring_operators1
 578     : totally_ordered1<T
 579     , euclidian_ring_operators1<T, B
 580       > > {};
 581
 582 template <class T, class P, class B = ::boost::detail::empty_base>
 583 struct input_iteratable
 584     : equality_comparable1<T
 585     , incrementable<T
 586     , dereferenceable<T, P, B
 587       > > > {};
 588
 589 template <class T, class B = ::boost::detail::empty_base>
 590 struct output_iteratable
 591     : incrementable<T, B
 592       > {};
 593
 594 template <class T, class P, class B = ::boost::detail::empty_base>
 595 struct forward_iteratable
 596     : input_iteratable<T, P, B
 597       > {};
 598
 599 template <class T, class P, class B = ::boost::detail::empty_base>
 600 struct bidirectional_iteratable
 601     : forward_iteratable<T, P
 602     , decrementable<T, B
 603       > > {};
 604
 605 //  To avoid repeated derivation from equality_comparable,
 606 //  which is an indirect base class of bidirectional_iterable,
 607 //  random_access_iteratable must not be derived from totally_ordered1
 608 //  but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
 609 template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
 610 struct random_access_iteratable
 611     : bidirectional_iteratable<T, P
 612     , less_than_comparable1<T
 613     , additive2<T, D
 614     , indexable<T, D, R, B
 615       > > > > {};
 616
 617 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 618 } // namespace boost
 619 #endif // BOOST_NO_OPERATORS_IN_NAMESPACE
 620
 621
 622 // BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
 623 //
 624 // When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
 625 // operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
 626 // for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
 627 // two-argument forms. Note that these macros expect to be invoked from within
 628 // boost.
 629
 630 #ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
 631
 632   // The template is already in boost so we have nothing to do.
 633 # define BOOST_IMPORT_TEMPLATE4(template_name)
 634 # define BOOST_IMPORT_TEMPLATE3(template_name)
 635 # define BOOST_IMPORT_TEMPLATE2(template_name)
 636 # define BOOST_IMPORT_TEMPLATE1(template_name)
 637
 638 #else // BOOST_NO_OPERATORS_IN_NAMESPACE
 639
 640 #  ifndef BOOST_NO_USING_TEMPLATE
 641
 642      // Bring the names in with a using-declaration
 643      // to avoid stressing the compiler.
 644 #    define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
 645 #    define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
 646 #    define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
 647 #    define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
 648
 649 #  else
 650
 651      // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
 652      // from working, we are forced to use inheritance for that compiler.
 653 #    define BOOST_IMPORT_TEMPLATE4(template_name)                                          \
 654      template <class T, class U, class V, class W, class B = ::boost::detail::empty_base>  \
 655      struct template_name : ::template_name<T, U, V, W, B> {};
 656
 657 #    define BOOST_IMPORT_TEMPLATE3(template_name)                                 \
 658      template <class T, class U, class V, class B = ::boost::detail::empty_base>  \
 659      struct template_name : ::template_name<T, U, V, B> {};
 660
 661 #    define BOOST_IMPORT_TEMPLATE2(template_name)                              \
 662      template <class T, class U, class B = ::boost::detail::empty_base>        \
 663      struct template_name : ::template_name<T, U, B> {};
 664
 665 #    define BOOST_IMPORT_TEMPLATE1(template_name)                              \
 666      template <class T, class B = ::boost::detail::empty_base>                 \
 667      struct template_name : ::template_name<T, B> {};
 668
 669 #  endif // BOOST_NO_USING_TEMPLATE
 670
 671 #endif // BOOST_NO_OPERATORS_IN_NAMESPACE
 672
 673 //
 674 // Here's where we put it all together, defining the xxxx forms of the templates
 675 // in namespace boost. We also define specializations of is_chained_base<> for
 676 // the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
 677 // necessary.
 678 //
 679 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 680
 681 // is_chained_base<> - a traits class used to distinguish whether an operator
 682 // template argument is being used for base class chaining, or is specifying a
 683 // 2nd argument type.
 684
 685 namespace boost {
 686 // A type parameter is used instead of a plain bool because Borland's compiler
 687 // didn't cope well with the more obvious non-type template parameter.
 688 namespace detail {
 689   struct true_t {};
 690   struct false_t {};
 691 } // namespace detail
 692
 693 // Unspecialized version assumes that most types are not being used for base
 694 // class chaining. We specialize for the operator templates defined in this
 695 // library.
 696 template<class T> struct is_chained_base {
 697   typedef ::boost::detail::false_t value;
 698 };
 699
 700 } // namespace boost
 701
 702 // Import a 4-type-argument operator template into boost (if necessary) and
 703 // provide a specialization of 'is_chained_base<>' for it.
 704 # define BOOST_OPERATOR_TEMPLATE4(template_name4)                     \
 705   BOOST_IMPORT_TEMPLATE4(template_name4)                              \
 706   template<class T, class U, class V, class W, class B>               \
 707   struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > {  \
 708     typedef ::boost::detail::true_t value;                            \
 709   };
 710
 711 // Import a 3-type-argument operator template into boost (if necessary) and
 712 // provide a specialization of 'is_chained_base<>' for it.
 713 # define BOOST_OPERATOR_TEMPLATE3(template_name3)                     \
 714   BOOST_IMPORT_TEMPLATE3(template_name3)                              \
 715   template<class T, class U, class V, class B>                        \
 716   struct is_chained_base< ::boost::template_name3<T, U, V, B> > {     \
 717     typedef ::boost::detail::true_t value;                            \
 718   };
 719
 720 // Import a 2-type-argument operator template into boost (if necessary) and
 721 // provide a specialization of 'is_chained_base<>' for it.
 722 # define BOOST_OPERATOR_TEMPLATE2(template_name2)                  \
 723   BOOST_IMPORT_TEMPLATE2(template_name2)                           \
 724   template<class T, class U, class B>                              \
 725   struct is_chained_base< ::boost::template_name2<T, U, B> > {     \
 726     typedef ::boost::detail::true_t value;                         \
 727   };
 728
 729 // Import a 1-type-argument operator template into boost (if necessary) and
 730 // provide a specialization of 'is_chained_base<>' for it.
 731 # define BOOST_OPERATOR_TEMPLATE1(template_name1)                  \
 732   BOOST_IMPORT_TEMPLATE1(template_name1)                           \
 733   template<class T, class B>                                       \
 734   struct is_chained_base< ::boost::template_name1<T, B> > {        \
 735     typedef ::boost::detail::true_t value;                         \
 736   };
 737
 738 // BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
 739 // can be used for specifying both 1-argument and 2-argument forms. Requires the
 740 // existence of two previously defined class templates named '<template_name>1'
 741 // and '<template_name>2' which must implement the corresponding 1- and 2-
 742 // argument forms.
 743 //
 744 // The template type parameter O == is_chained_base<U>::value is used to
 745 // distinguish whether the 2nd argument to <template_name> is being used for
 746 // base class chaining from another boost operator template or is describing a
 747 // 2nd operand type. O == true_t only when U is actually an another operator
 748 // template from the library. Partial specialization is used to select an
 749 // implementation in terms of either '<template_name>1' or '<template_name>2'.
 750 //
 751
 752 # define BOOST_OPERATOR_TEMPLATE(template_name)                    \
 753 template <class T                                                  \
 754          ,class U = T                                              \
 755          ,class B = ::boost::detail::empty_base                    \
 756          ,class O = typename is_chained_base<U>::value             \
 757          >                                                         \
 758 struct template_name : template_name##2<T, U, B> {};               \
 759                                                                    \
 760 template<class T, class U, class B>                                \
 761 struct template_name<T, U, B, ::boost::detail::true_t>             \
 762   : template_name##1<T, U> {};                                     \
 763                                                                    \
 764 template <class T, class B>                                        \
 765 struct template_name<T, T, B, ::boost::detail::false_t>            \
 766   : template_name##1<T, B> {};                                     \
 767                                                                    \
 768 template<class T, class U, class B, class O>                       \
 769 struct is_chained_base< ::boost::template_name<T, U, B, O> > {     \
 770   typedef ::boost::detail::true_t value;                           \
 771 };                                                                 \
 772                                                                    \
 773 BOOST_OPERATOR_TEMPLATE2(template_name##2)                         \
 774 BOOST_OPERATOR_TEMPLATE1(template_name##1)
 775
 776
 777 #else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 778
 779 #  define BOOST_OPERATOR_TEMPLATE4(template_name4) \
 780         BOOST_IMPORT_TEMPLATE4(template_name4)
 781 #  define BOOST_OPERATOR_TEMPLATE3(template_name3) \
 782         BOOST_IMPORT_TEMPLATE3(template_name3)
 783 #  define BOOST_OPERATOR_TEMPLATE2(template_name2) \
 784         BOOST_IMPORT_TEMPLATE2(template_name2)
 785 #  define BOOST_OPERATOR_TEMPLATE1(template_name1) \
 786         BOOST_IMPORT_TEMPLATE1(template_name1)
 787
 788    // In this case we can only assume that template_name<> is equivalent to the
 789    // more commonly needed template_name1<> form.
 790 #  define BOOST_OPERATOR_TEMPLATE(template_name)                   \
 791    template <class T, class B = ::boost::detail::empty_base>       \
 792    struct template_name : template_name##1<T, B> {};
 793
 794 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 795
 796 namespace boost {
 797
 798 BOOST_OPERATOR_TEMPLATE(less_than_comparable)
 799 BOOST_OPERATOR_TEMPLATE(equality_comparable)
 800 BOOST_OPERATOR_TEMPLATE(multipliable)
 801 BOOST_OPERATOR_TEMPLATE(addable)
 802 BOOST_OPERATOR_TEMPLATE(subtractable)
 803 BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
 804 BOOST_OPERATOR_TEMPLATE(dividable)
 805 BOOST_OPERATOR_TEMPLATE2(dividable2_left)
 806 BOOST_OPERATOR_TEMPLATE(modable)
 807 BOOST_OPERATOR_TEMPLATE2(modable2_left)
 808 BOOST_OPERATOR_TEMPLATE(xorable)
 809 BOOST_OPERATOR_TEMPLATE(andable)
 810 BOOST_OPERATOR_TEMPLATE(orable)
 811
 812 BOOST_OPERATOR_TEMPLATE1(incrementable)
 813 BOOST_OPERATOR_TEMPLATE1(decrementable)
 814
 815 BOOST_OPERATOR_TEMPLATE2(dereferenceable)
 816 BOOST_OPERATOR_TEMPLATE3(indexable)
 817
 818 BOOST_OPERATOR_TEMPLATE(left_shiftable)
 819 BOOST_OPERATOR_TEMPLATE(right_shiftable)
 820 BOOST_OPERATOR_TEMPLATE(equivalent)
 821 BOOST_OPERATOR_TEMPLATE(partially_ordered)
 822
 823 BOOST_OPERATOR_TEMPLATE(totally_ordered)
 824 BOOST_OPERATOR_TEMPLATE(additive)
 825 BOOST_OPERATOR_TEMPLATE(multiplicative)
 826 BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
 827 BOOST_OPERATOR_TEMPLATE(arithmetic)
 828 BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
 829 BOOST_OPERATOR_TEMPLATE(bitwise)
 830 BOOST_OPERATOR_TEMPLATE1(unit_steppable)
 831 BOOST_OPERATOR_TEMPLATE(shiftable)
 832 BOOST_OPERATOR_TEMPLATE(ring_operators)
 833 BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
 834 BOOST_OPERATOR_TEMPLATE(field_operators)
 835 BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
 836 BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
 837 BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
 838 BOOST_OPERATOR_TEMPLATE2(input_iteratable)
 839 BOOST_OPERATOR_TEMPLATE1(output_iteratable)
 840 BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
 841 BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
 842 BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
 843
 844 #undef BOOST_OPERATOR_TEMPLATE
 845 #undef BOOST_OPERATOR_TEMPLATE4
 846 #undef BOOST_OPERATOR_TEMPLATE3
 847 #undef BOOST_OPERATOR_TEMPLATE2
 848 #undef BOOST_OPERATOR_TEMPLATE1
 849 #undef BOOST_IMPORT_TEMPLATE1
 850 #undef BOOST_IMPORT_TEMPLATE2
 851 #undef BOOST_IMPORT_TEMPLATE3
 852 #undef BOOST_IMPORT_TEMPLATE4
 853
 854 // The following 'operators' classes can only be used portably if the derived class
 855 // declares ALL of the required member operators.
 856 template <class T, class U>
 857 struct operators2
 858     : totally_ordered2<T,U
 859     , integer_arithmetic2<T,U
 860     , bitwise2<T,U
 861       > > > {};
 862
 863 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 864 template <class T, class U = T>
 865 struct operators : operators2<T, U> {};
 866
 867 template <class T> struct operators<T, T>
 868 #else
 869 template <class T> struct operators
 870 #endif
 871     : totally_ordered<T
 872     , integer_arithmetic<T
 873     , bitwise<T
 874     , unit_steppable<T
 875       > > > > {};
 876
 877 //  Iterator helper classes (contributed by Jeremy Siek) -------------------//
 878 //  (Input and output iterator helpers contributed by Daryle Walker) -------//
 879 //  (Changed to use combined operator classes by Daryle Walker) ------------//
 880 template <class T,
 881           class V,
 882           class D = std::ptrdiff_t,
 883           class P = V const *,
 884           class R = V const &>
 885 struct input_iterator_helper
 886   : input_iteratable<T, P
 887   , boost::iterator<std::input_iterator_tag, V, D, P, R
 888     > > {};
 889
 890 template<class T>
 891 struct output_iterator_helper
 892   : output_iteratable<T
 893   , boost::iterator<std::output_iterator_tag, void, void, void, void
 894   > >
 895 {
 896   T& operator*()  { return static_cast<T&>(*this); }
 897   T& operator++() { return static_cast<T&>(*this); }
 898 };
 899
 900 template <class T,
 901           class V,
 902           class D = std::ptrdiff_t,
 903           class P = V*,
 904           class R = V&>
 905 struct forward_iterator_helper
 906   : forward_iteratable<T, P
 907   , boost::iterator<std::forward_iterator_tag, V, D, P, R
 908     > > {};
 909
 910 template <class T,
 911           class V,
 912           class D = std::ptrdiff_t,
 913           class P = V*,
 914           class R = V&>
 915 struct bidirectional_iterator_helper
 916   : bidirectional_iteratable<T, P
 917   , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
 918     > > {};
 919
 920 template <class T,
 921           class V,
 922           class D = std::ptrdiff_t,
 923           class P = V*,
 924           class R = V&>
 925 struct random_access_iterator_helper
 926   : random_access_iteratable<T, P, D, R
 927   , boost::iterator<std::random_access_iterator_tag, V, D, P, R
 928     > >
 929 {
 930   friend D requires_difference_operator(const T& x, const T& y) {
 931     return x - y;
 932   }
 933 }; // random_access_iterator_helper
 934
 935 } // namespace boost
 936
 937 #if defined(__sgi) && !defined(__GNUC__)
 938 #pragma reset woff 1234
 939 #endif
 940
 941 #endif // BOOST_OPERATORS_HPP