1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/epoc32/include/stdapis/boost/operators.hpp Wed Mar 31 12:33:34 2010 +0100
1.3 @@ -0,0 +1,941 @@
1.4 +// Boost operators.hpp header file ----------------------------------------//
1.5 +
1.6 +// (C) Copyright David Abrahams, Jeremy Siek, Daryle Walker 1999-2001.
1.7 +// Distributed under the Boost Software License, Version 1.0. (See
1.8 +// accompanying file LICENSE_1_0.txt or copy at
1.9 +// http://www.boost.org/LICENSE_1_0.txt)
1.10 +
1.11 +// See http://www.boost.org/libs/utility/operators.htm for documentation.
1.12 +
1.13 +// Revision History
1.14 +// 21 Oct 02 Modified implementation of operators to allow compilers with a
1.15 +// correct named return value optimization (NRVO) to produce optimal
1.16 +// code. (Daniel Frey)
1.17 +// 02 Dec 01 Bug fixed in random_access_iteratable. (Helmut Zeisel)
1.18 +// 28 Sep 01 Factored out iterator operator groups. (Daryle Walker)
1.19 +// 27 Aug 01 'left' form for non commutative operators added;
1.20 +// additional classes for groups of related operators added;
1.21 +// workaround for empty base class optimization
1.22 +// bug of GCC 3.0 (Helmut Zeisel)
1.23 +// 25 Jun 01 output_iterator_helper changes: removed default template
1.24 +// parameters, added support for self-proxying, additional
1.25 +// documentation and tests (Aleksey Gurtovoy)
1.26 +// 29 May 01 Added operator classes for << and >>. Added input and output
1.27 +// iterator helper classes. Added classes to connect equality and
1.28 +// relational operators. Added classes for groups of related
1.29 +// operators. Reimplemented example operator and iterator helper
1.30 +// classes in terms of the new groups. (Daryle Walker, with help
1.31 +// from Alexy Gurtovoy)
1.32 +// 11 Feb 01 Fixed bugs in the iterator helpers which prevented explicitly
1.33 +// supplied arguments from actually being used (Dave Abrahams)
1.34 +// 04 Jul 00 Fixed NO_OPERATORS_IN_NAMESPACE bugs, major cleanup and
1.35 +// refactoring of compiler workarounds, additional documentation
1.36 +// (Alexy Gurtovoy and Mark Rodgers with some help and prompting from
1.37 +// Dave Abrahams)
1.38 +// 28 Jun 00 General cleanup and integration of bugfixes from Mark Rodgers and
1.39 +// Jeremy Siek (Dave Abrahams)
1.40 +// 20 Jun 00 Changes to accommodate Borland C++Builder 4 and Borland C++ 5.5
1.41 +// (Mark Rodgers)
1.42 +// 20 Jun 00 Minor fixes to the prior revision (Aleksey Gurtovoy)
1.43 +// 10 Jun 00 Support for the base class chaining technique was added
1.44 +// (Aleksey Gurtovoy). See documentation and the comments below
1.45 +// for the details.
1.46 +// 12 Dec 99 Initial version with iterator operators (Jeremy Siek)
1.47 +// 18 Nov 99 Change name "divideable" to "dividable", remove unnecessary
1.48 +// specializations of dividable, subtractable, modable (Ed Brey)
1.49 +// 17 Nov 99 Add comments (Beman Dawes)
1.50 +// Remove unnecessary specialization of operators<> (Ed Brey)
1.51 +// 15 Nov 99 Fix less_than_comparable<T,U> second operand type for first two
1.52 +// operators.(Beman Dawes)
1.53 +// 12 Nov 99 Add operators templates (Ed Brey)
1.54 +// 11 Nov 99 Add single template parameter version for compilers without
1.55 +// partial specialization (Beman Dawes)
1.56 +// 10 Nov 99 Initial version
1.57 +
1.58 +// 10 Jun 00:
1.59 +// An additional optional template parameter was added to most of
1.60 +// operator templates to support the base class chaining technique (see
1.61 +// documentation for the details). Unfortunately, a straightforward
1.62 +// implementation of this change would have broken compatibility with the
1.63 +// previous version of the library by making it impossible to use the same
1.64 +// template name (e.g. 'addable') for both the 1- and 2-argument versions of
1.65 +// an operator template. This implementation solves the backward-compatibility
1.66 +// issue at the cost of some simplicity.
1.67 +//
1.68 +// One of the complications is an existence of special auxiliary class template
1.69 +// 'is_chained_base<>' (see 'detail' namespace below), which is used
1.70 +// to determine whether its template parameter is a library's operator template
1.71 +// or not. You have to specialize 'is_chained_base<>' for each new
1.72 +// operator template you add to the library.
1.73 +//
1.74 +// However, most of the non-trivial implementation details are hidden behind
1.75 +// several local macros defined below, and as soon as you understand them,
1.76 +// you understand the whole library implementation.
1.77 +
1.78 +#ifndef BOOST_OPERATORS_HPP
1.79 +#define BOOST_OPERATORS_HPP
1.80 +
1.81 +#include <boost/config.hpp>
1.82 +#include <boost/iterator.hpp>
1.83 +#include <boost/detail/workaround.hpp>
1.84 +
1.85 +#if defined(__sgi) && !defined(__GNUC__)
1.86 +# pragma set woff 1234
1.87 +#endif
1.88 +
1.89 +#if defined(BOOST_MSVC)
1.90 +# pragma warning( disable : 4284 ) // complaint about return type of
1.91 +#endif // operator-> not begin a UDT
1.92 +
1.93 +namespace boost {
1.94 +namespace detail {
1.95 +
1.96 +// Helmut Zeisel, empty base class optimization bug with GCC 3.0.0
1.97 +#if defined(__GNUC__) && __GNUC__==3 && __GNUC_MINOR__==0 && __GNU_PATCHLEVEL__==0
1.98 +class empty_base {
1.99 + bool dummy;
1.100 +};
1.101 +#else
1.102 +class empty_base {};
1.103 +#endif
1.104 +
1.105 +} // namespace detail
1.106 +} // namespace boost
1.107 +
1.108 +// In this section we supply the xxxx1 and xxxx2 forms of the operator
1.109 +// templates, which are explicitly targeted at the 1-type-argument and
1.110 +// 2-type-argument operator forms, respectively. Some compilers get confused
1.111 +// when inline friend functions are overloaded in namespaces other than the
1.112 +// global namespace. When BOOST_NO_OPERATORS_IN_NAMESPACE is defined, all of
1.113 +// these templates must go in the global namespace.
1.114 +
1.115 +#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
1.116 +namespace boost
1.117 +{
1.118 +#endif
1.119 +
1.120 +// Basic operator classes (contributed by Dave Abrahams) ------------------//
1.121 +
1.122 +// Note that friend functions defined in a class are implicitly inline.
1.123 +// See the C++ std, 11.4 [class.friend] paragraph 5
1.124 +
1.125 +template <class T, class U, class B = ::boost::detail::empty_base>
1.126 +struct less_than_comparable2 : B
1.127 +{
1.128 + friend bool operator<=(const T& x, const U& y) { return !(x > y); }
1.129 + friend bool operator>=(const T& x, const U& y) { return !(x < y); }
1.130 + friend bool operator>(const U& x, const T& y) { return y < x; }
1.131 + friend bool operator<(const U& x, const T& y) { return y > x; }
1.132 + friend bool operator<=(const U& x, const T& y) { return !(y < x); }
1.133 + friend bool operator>=(const U& x, const T& y) { return !(y > x); }
1.134 +};
1.135 +
1.136 +template <class T, class B = ::boost::detail::empty_base>
1.137 +struct less_than_comparable1 : B
1.138 +{
1.139 + friend bool operator>(const T& x, const T& y) { return y < x; }
1.140 + friend bool operator<=(const T& x, const T& y) { return !(y < x); }
1.141 + friend bool operator>=(const T& x, const T& y) { return !(x < y); }
1.142 +};
1.143 +
1.144 +template <class T, class U, class B = ::boost::detail::empty_base>
1.145 +struct equality_comparable2 : B
1.146 +{
1.147 + friend bool operator==(const U& y, const T& x) { return x == y; }
1.148 + friend bool operator!=(const U& y, const T& x) { return !(x == y); }
1.149 + friend bool operator!=(const T& y, const U& x) { return !(y == x); }
1.150 +};
1.151 +
1.152 +template <class T, class B = ::boost::detail::empty_base>
1.153 +struct equality_comparable1 : B
1.154 +{
1.155 + friend bool operator!=(const T& x, const T& y) { return !(x == y); }
1.156 +};
1.157 +
1.158 +// A macro which produces "name_2left" from "name".
1.159 +#define BOOST_OPERATOR2_LEFT(name) name##2##_##left
1.160 +
1.161 +// NRVO-friendly implementation (contributed by Daniel Frey) ---------------//
1.162 +
1.163 +#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
1.164 +
1.165 +// This is the optimal implementation for ISO/ANSI C++,
1.166 +// but it requires the compiler to implement the NRVO.
1.167 +// If the compiler has no NRVO, this is the best symmetric
1.168 +// implementation available.
1.169 +
1.170 +#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
1.171 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.172 +struct NAME##2 : B \
1.173 +{ \
1.174 + friend T operator OP( const T& lhs, const U& rhs ) \
1.175 + { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
1.176 + friend T operator OP( const U& lhs, const T& rhs ) \
1.177 + { T nrv( rhs ); nrv OP##= lhs; return nrv; } \
1.178 +}; \
1.179 + \
1.180 +template <class T, class B = ::boost::detail::empty_base> \
1.181 +struct NAME##1 : B \
1.182 +{ \
1.183 + friend T operator OP( const T& lhs, const T& rhs ) \
1.184 + { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
1.185 +};
1.186 +
1.187 +#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
1.188 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.189 +struct NAME##2 : B \
1.190 +{ \
1.191 + friend T operator OP( const T& lhs, const U& rhs ) \
1.192 + { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
1.193 +}; \
1.194 + \
1.195 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.196 +struct BOOST_OPERATOR2_LEFT(NAME) : B \
1.197 +{ \
1.198 + friend T operator OP( const U& lhs, const T& rhs ) \
1.199 + { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
1.200 +}; \
1.201 + \
1.202 +template <class T, class B = ::boost::detail::empty_base> \
1.203 +struct NAME##1 : B \
1.204 +{ \
1.205 + friend T operator OP( const T& lhs, const T& rhs ) \
1.206 + { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
1.207 +};
1.208 +
1.209 +#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
1.210 +
1.211 +// For compilers without NRVO the following code is optimal, but not
1.212 +// symmetric! Note that the implementation of
1.213 +// BOOST_OPERATOR2_LEFT(NAME) only looks cool, but doesn't provide
1.214 +// optimization opportunities to the compiler :)
1.215 +
1.216 +#define BOOST_BINARY_OPERATOR_COMMUTATIVE( NAME, OP ) \
1.217 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.218 +struct NAME##2 : B \
1.219 +{ \
1.220 + friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
1.221 + friend T operator OP( const U& lhs, T rhs ) { return rhs OP##= lhs; } \
1.222 +}; \
1.223 + \
1.224 +template <class T, class B = ::boost::detail::empty_base> \
1.225 +struct NAME##1 : B \
1.226 +{ \
1.227 + friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
1.228 +};
1.229 +
1.230 +#define BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( NAME, OP ) \
1.231 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.232 +struct NAME##2 : B \
1.233 +{ \
1.234 + friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
1.235 +}; \
1.236 + \
1.237 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.238 +struct BOOST_OPERATOR2_LEFT(NAME) : B \
1.239 +{ \
1.240 + friend T operator OP( const U& lhs, const T& rhs ) \
1.241 + { return T( lhs ) OP##= rhs; } \
1.242 +}; \
1.243 + \
1.244 +template <class T, class B = ::boost::detail::empty_base> \
1.245 +struct NAME##1 : B \
1.246 +{ \
1.247 + friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
1.248 +};
1.249 +
1.250 +#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
1.251 +
1.252 +BOOST_BINARY_OPERATOR_COMMUTATIVE( multipliable, * )
1.253 +BOOST_BINARY_OPERATOR_COMMUTATIVE( addable, + )
1.254 +BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( subtractable, - )
1.255 +BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( dividable, / )
1.256 +BOOST_BINARY_OPERATOR_NON_COMMUTATIVE( modable, % )
1.257 +BOOST_BINARY_OPERATOR_COMMUTATIVE( xorable, ^ )
1.258 +BOOST_BINARY_OPERATOR_COMMUTATIVE( andable, & )
1.259 +BOOST_BINARY_OPERATOR_COMMUTATIVE( orable, | )
1.260 +
1.261 +#undef BOOST_BINARY_OPERATOR_COMMUTATIVE
1.262 +#undef BOOST_BINARY_OPERATOR_NON_COMMUTATIVE
1.263 +#undef BOOST_OPERATOR2_LEFT
1.264 +
1.265 +// incrementable and decrementable contributed by Jeremy Siek
1.266 +
1.267 +template <class T, class B = ::boost::detail::empty_base>
1.268 +struct incrementable : B
1.269 +{
1.270 + friend T operator++(T& x, int)
1.271 + {
1.272 + incrementable_type nrv(x);
1.273 + ++x;
1.274 + return nrv;
1.275 + }
1.276 +private: // The use of this typedef works around a Borland bug
1.277 + typedef T incrementable_type;
1.278 +};
1.279 +
1.280 +template <class T, class B = ::boost::detail::empty_base>
1.281 +struct decrementable : B
1.282 +{
1.283 + friend T operator--(T& x, int)
1.284 + {
1.285 + decrementable_type nrv(x);
1.286 + --x;
1.287 + return nrv;
1.288 + }
1.289 +private: // The use of this typedef works around a Borland bug
1.290 + typedef T decrementable_type;
1.291 +};
1.292 +
1.293 +// Iterator operator classes (contributed by Jeremy Siek) ------------------//
1.294 +
1.295 +template <class T, class P, class B = ::boost::detail::empty_base>
1.296 +struct dereferenceable : B
1.297 +{
1.298 + P operator->() const
1.299 + {
1.300 + return &*static_cast<const T&>(*this);
1.301 + }
1.302 +};
1.303 +
1.304 +template <class T, class I, class R, class B = ::boost::detail::empty_base>
1.305 +struct indexable : B
1.306 +{
1.307 + R operator[](I n) const
1.308 + {
1.309 + return *(static_cast<const T&>(*this) + n);
1.310 + }
1.311 +};
1.312 +
1.313 +// More operator classes (contributed by Daryle Walker) --------------------//
1.314 +// (NRVO-friendly implementation contributed by Daniel Frey) ---------------//
1.315 +
1.316 +#if defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
1.317 +
1.318 +#define BOOST_BINARY_OPERATOR( NAME, OP ) \
1.319 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.320 +struct NAME##2 : B \
1.321 +{ \
1.322 + friend T operator OP( const T& lhs, const U& rhs ) \
1.323 + { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
1.324 +}; \
1.325 + \
1.326 +template <class T, class B = ::boost::detail::empty_base> \
1.327 +struct NAME##1 : B \
1.328 +{ \
1.329 + friend T operator OP( const T& lhs, const T& rhs ) \
1.330 + { T nrv( lhs ); nrv OP##= rhs; return nrv; } \
1.331 +};
1.332 +
1.333 +#else // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
1.334 +
1.335 +#define BOOST_BINARY_OPERATOR( NAME, OP ) \
1.336 +template <class T, class U, class B = ::boost::detail::empty_base> \
1.337 +struct NAME##2 : B \
1.338 +{ \
1.339 + friend T operator OP( T lhs, const U& rhs ) { return lhs OP##= rhs; } \
1.340 +}; \
1.341 + \
1.342 +template <class T, class B = ::boost::detail::empty_base> \
1.343 +struct NAME##1 : B \
1.344 +{ \
1.345 + friend T operator OP( T lhs, const T& rhs ) { return lhs OP##= rhs; } \
1.346 +};
1.347 +
1.348 +#endif // defined(BOOST_HAS_NRVO) || defined(BOOST_FORCE_SYMMETRIC_OPERATORS)
1.349 +
1.350 +BOOST_BINARY_OPERATOR( left_shiftable, << )
1.351 +BOOST_BINARY_OPERATOR( right_shiftable, >> )
1.352 +
1.353 +#undef BOOST_BINARY_OPERATOR
1.354 +
1.355 +template <class T, class U, class B = ::boost::detail::empty_base>
1.356 +struct equivalent2 : B
1.357 +{
1.358 + friend bool operator==(const T& x, const U& y)
1.359 + {
1.360 + return !(x < y) && !(x > y);
1.361 + }
1.362 +};
1.363 +
1.364 +template <class T, class B = ::boost::detail::empty_base>
1.365 +struct equivalent1 : B
1.366 +{
1.367 + friend bool operator==(const T&x, const T&y)
1.368 + {
1.369 + return !(x < y) && !(y < x);
1.370 + }
1.371 +};
1.372 +
1.373 +template <class T, class U, class B = ::boost::detail::empty_base>
1.374 +struct partially_ordered2 : B
1.375 +{
1.376 + friend bool operator<=(const T& x, const U& y)
1.377 + { return (x < y) || (x == y); }
1.378 + friend bool operator>=(const T& x, const U& y)
1.379 + { return (x > y) || (x == y); }
1.380 + friend bool operator>(const U& x, const T& y)
1.381 + { return y < x; }
1.382 + friend bool operator<(const U& x, const T& y)
1.383 + { return y > x; }
1.384 + friend bool operator<=(const U& x, const T& y)
1.385 + { return (y > x) || (y == x); }
1.386 + friend bool operator>=(const U& x, const T& y)
1.387 + { return (y < x) || (y == x); }
1.388 +};
1.389 +
1.390 +template <class T, class B = ::boost::detail::empty_base>
1.391 +struct partially_ordered1 : B
1.392 +{
1.393 + friend bool operator>(const T& x, const T& y)
1.394 + { return y < x; }
1.395 + friend bool operator<=(const T& x, const T& y)
1.396 + { return (x < y) || (x == y); }
1.397 + friend bool operator>=(const T& x, const T& y)
1.398 + { return (y < x) || (x == y); }
1.399 +};
1.400 +
1.401 +// Combined operator classes (contributed by Daryle Walker) ----------------//
1.402 +
1.403 +template <class T, class U, class B = ::boost::detail::empty_base>
1.404 +struct totally_ordered2
1.405 + : less_than_comparable2<T, U
1.406 + , equality_comparable2<T, U, B
1.407 + > > {};
1.408 +
1.409 +template <class T, class B = ::boost::detail::empty_base>
1.410 +struct totally_ordered1
1.411 + : less_than_comparable1<T
1.412 + , equality_comparable1<T, B
1.413 + > > {};
1.414 +
1.415 +template <class T, class U, class B = ::boost::detail::empty_base>
1.416 +struct additive2
1.417 + : addable2<T, U
1.418 + , subtractable2<T, U, B
1.419 + > > {};
1.420 +
1.421 +template <class T, class B = ::boost::detail::empty_base>
1.422 +struct additive1
1.423 + : addable1<T
1.424 + , subtractable1<T, B
1.425 + > > {};
1.426 +
1.427 +template <class T, class U, class B = ::boost::detail::empty_base>
1.428 +struct multiplicative2
1.429 + : multipliable2<T, U
1.430 + , dividable2<T, U, B
1.431 + > > {};
1.432 +
1.433 +template <class T, class B = ::boost::detail::empty_base>
1.434 +struct multiplicative1
1.435 + : multipliable1<T
1.436 + , dividable1<T, B
1.437 + > > {};
1.438 +
1.439 +template <class T, class U, class B = ::boost::detail::empty_base>
1.440 +struct integer_multiplicative2
1.441 + : multiplicative2<T, U
1.442 + , modable2<T, U, B
1.443 + > > {};
1.444 +
1.445 +template <class T, class B = ::boost::detail::empty_base>
1.446 +struct integer_multiplicative1
1.447 + : multiplicative1<T
1.448 + , modable1<T, B
1.449 + > > {};
1.450 +
1.451 +template <class T, class U, class B = ::boost::detail::empty_base>
1.452 +struct arithmetic2
1.453 + : additive2<T, U
1.454 + , multiplicative2<T, U, B
1.455 + > > {};
1.456 +
1.457 +template <class T, class B = ::boost::detail::empty_base>
1.458 +struct arithmetic1
1.459 + : additive1<T
1.460 + , multiplicative1<T, B
1.461 + > > {};
1.462 +
1.463 +template <class T, class U, class B = ::boost::detail::empty_base>
1.464 +struct integer_arithmetic2
1.465 + : additive2<T, U
1.466 + , integer_multiplicative2<T, U, B
1.467 + > > {};
1.468 +
1.469 +template <class T, class B = ::boost::detail::empty_base>
1.470 +struct integer_arithmetic1
1.471 + : additive1<T
1.472 + , integer_multiplicative1<T, B
1.473 + > > {};
1.474 +
1.475 +template <class T, class U, class B = ::boost::detail::empty_base>
1.476 +struct bitwise2
1.477 + : xorable2<T, U
1.478 + , andable2<T, U
1.479 + , orable2<T, U, B
1.480 + > > > {};
1.481 +
1.482 +template <class T, class B = ::boost::detail::empty_base>
1.483 +struct bitwise1
1.484 + : xorable1<T
1.485 + , andable1<T
1.486 + , orable1<T, B
1.487 + > > > {};
1.488 +
1.489 +template <class T, class B = ::boost::detail::empty_base>
1.490 +struct unit_steppable
1.491 + : incrementable<T
1.492 + , decrementable<T, B
1.493 + > > {};
1.494 +
1.495 +template <class T, class U, class B = ::boost::detail::empty_base>
1.496 +struct shiftable2
1.497 + : left_shiftable2<T, U
1.498 + , right_shiftable2<T, U, B
1.499 + > > {};
1.500 +
1.501 +template <class T, class B = ::boost::detail::empty_base>
1.502 +struct shiftable1
1.503 + : left_shiftable1<T
1.504 + , right_shiftable1<T, B
1.505 + > > {};
1.506 +
1.507 +template <class T, class U, class B = ::boost::detail::empty_base>
1.508 +struct ring_operators2
1.509 + : additive2<T, U
1.510 + , subtractable2_left<T, U
1.511 + , multipliable2<T, U, B
1.512 + > > > {};
1.513 +
1.514 +template <class T, class B = ::boost::detail::empty_base>
1.515 +struct ring_operators1
1.516 + : additive1<T
1.517 + , multipliable1<T, B
1.518 + > > {};
1.519 +
1.520 +template <class T, class U, class B = ::boost::detail::empty_base>
1.521 +struct ordered_ring_operators2
1.522 + : ring_operators2<T, U
1.523 + , totally_ordered2<T, U, B
1.524 + > > {};
1.525 +
1.526 +template <class T, class B = ::boost::detail::empty_base>
1.527 +struct ordered_ring_operators1
1.528 + : ring_operators1<T
1.529 + , totally_ordered1<T, B
1.530 + > > {};
1.531 +
1.532 +template <class T, class U, class B = ::boost::detail::empty_base>
1.533 +struct field_operators2
1.534 + : ring_operators2<T, U
1.535 + , dividable2<T, U
1.536 + , dividable2_left<T, U, B
1.537 + > > > {};
1.538 +
1.539 +template <class T, class B = ::boost::detail::empty_base>
1.540 +struct field_operators1
1.541 + : ring_operators1<T
1.542 + , dividable1<T, B
1.543 + > > {};
1.544 +
1.545 +template <class T, class U, class B = ::boost::detail::empty_base>
1.546 +struct ordered_field_operators2
1.547 + : field_operators2<T, U
1.548 + , totally_ordered2<T, U, B
1.549 + > > {};
1.550 +
1.551 +template <class T, class B = ::boost::detail::empty_base>
1.552 +struct ordered_field_operators1
1.553 + : field_operators1<T
1.554 + , totally_ordered1<T, B
1.555 + > > {};
1.556 +
1.557 +template <class T, class U, class B = ::boost::detail::empty_base>
1.558 +struct euclidian_ring_operators2
1.559 + : ring_operators2<T, U
1.560 + , dividable2<T, U
1.561 + , dividable2_left<T, U
1.562 + , modable2<T, U
1.563 + , modable2_left<T, U, B
1.564 + > > > > > {};
1.565 +
1.566 +template <class T, class B = ::boost::detail::empty_base>
1.567 +struct euclidian_ring_operators1
1.568 + : ring_operators1<T
1.569 + , dividable1<T
1.570 + , modable1<T, B
1.571 + > > > {};
1.572 +
1.573 +template <class T, class U, class B = ::boost::detail::empty_base>
1.574 +struct ordered_euclidian_ring_operators2
1.575 + : totally_ordered2<T, U
1.576 + , euclidian_ring_operators2<T, U, B
1.577 + > > {};
1.578 +
1.579 +template <class T, class B = ::boost::detail::empty_base>
1.580 +struct ordered_euclidian_ring_operators1
1.581 + : totally_ordered1<T
1.582 + , euclidian_ring_operators1<T, B
1.583 + > > {};
1.584 +
1.585 +template <class T, class P, class B = ::boost::detail::empty_base>
1.586 +struct input_iteratable
1.587 + : equality_comparable1<T
1.588 + , incrementable<T
1.589 + , dereferenceable<T, P, B
1.590 + > > > {};
1.591 +
1.592 +template <class T, class B = ::boost::detail::empty_base>
1.593 +struct output_iteratable
1.594 + : incrementable<T, B
1.595 + > {};
1.596 +
1.597 +template <class T, class P, class B = ::boost::detail::empty_base>
1.598 +struct forward_iteratable
1.599 + : input_iteratable<T, P, B
1.600 + > {};
1.601 +
1.602 +template <class T, class P, class B = ::boost::detail::empty_base>
1.603 +struct bidirectional_iteratable
1.604 + : forward_iteratable<T, P
1.605 + , decrementable<T, B
1.606 + > > {};
1.607 +
1.608 +// To avoid repeated derivation from equality_comparable,
1.609 +// which is an indirect base class of bidirectional_iterable,
1.610 +// random_access_iteratable must not be derived from totally_ordered1
1.611 +// but from less_than_comparable1 only. (Helmut Zeisel, 02-Dec-2001)
1.612 +template <class T, class P, class D, class R, class B = ::boost::detail::empty_base>
1.613 +struct random_access_iteratable
1.614 + : bidirectional_iteratable<T, P
1.615 + , less_than_comparable1<T
1.616 + , additive2<T, D
1.617 + , indexable<T, D, R, B
1.618 + > > > > {};
1.619 +
1.620 +#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
1.621 +} // namespace boost
1.622 +#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
1.623 +
1.624 +
1.625 +// BOOST_IMPORT_TEMPLATE1 .. BOOST_IMPORT_TEMPLATE4 -
1.626 +//
1.627 +// When BOOST_NO_OPERATORS_IN_NAMESPACE is defined we need a way to import an
1.628 +// operator template into the boost namespace. BOOST_IMPORT_TEMPLATE1 is used
1.629 +// for one-argument forms of operator templates; BOOST_IMPORT_TEMPLATE2 for
1.630 +// two-argument forms. Note that these macros expect to be invoked from within
1.631 +// boost.
1.632 +
1.633 +#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
1.634 +
1.635 + // The template is already in boost so we have nothing to do.
1.636 +# define BOOST_IMPORT_TEMPLATE4(template_name)
1.637 +# define BOOST_IMPORT_TEMPLATE3(template_name)
1.638 +# define BOOST_IMPORT_TEMPLATE2(template_name)
1.639 +# define BOOST_IMPORT_TEMPLATE1(template_name)
1.640 +
1.641 +#else // BOOST_NO_OPERATORS_IN_NAMESPACE
1.642 +
1.643 +# ifndef BOOST_NO_USING_TEMPLATE
1.644 +
1.645 + // Bring the names in with a using-declaration
1.646 + // to avoid stressing the compiler.
1.647 +# define BOOST_IMPORT_TEMPLATE4(template_name) using ::template_name;
1.648 +# define BOOST_IMPORT_TEMPLATE3(template_name) using ::template_name;
1.649 +# define BOOST_IMPORT_TEMPLATE2(template_name) using ::template_name;
1.650 +# define BOOST_IMPORT_TEMPLATE1(template_name) using ::template_name;
1.651 +
1.652 +# else
1.653 +
1.654 + // Otherwise, because a Borland C++ 5.5 bug prevents a using declaration
1.655 + // from working, we are forced to use inheritance for that compiler.
1.656 +# define BOOST_IMPORT_TEMPLATE4(template_name) \
1.657 + template <class T, class U, class V, class W, class B = ::boost::detail::empty_base> \
1.658 + struct template_name : ::template_name<T, U, V, W, B> {};
1.659 +
1.660 +# define BOOST_IMPORT_TEMPLATE3(template_name) \
1.661 + template <class T, class U, class V, class B = ::boost::detail::empty_base> \
1.662 + struct template_name : ::template_name<T, U, V, B> {};
1.663 +
1.664 +# define BOOST_IMPORT_TEMPLATE2(template_name) \
1.665 + template <class T, class U, class B = ::boost::detail::empty_base> \
1.666 + struct template_name : ::template_name<T, U, B> {};
1.667 +
1.668 +# define BOOST_IMPORT_TEMPLATE1(template_name) \
1.669 + template <class T, class B = ::boost::detail::empty_base> \
1.670 + struct template_name : ::template_name<T, B> {};
1.671 +
1.672 +# endif // BOOST_NO_USING_TEMPLATE
1.673 +
1.674 +#endif // BOOST_NO_OPERATORS_IN_NAMESPACE
1.675 +
1.676 +//
1.677 +// Here's where we put it all together, defining the xxxx forms of the templates
1.678 +// in namespace boost. We also define specializations of is_chained_base<> for
1.679 +// the xxxx, xxxx1, and xxxx2 templates, importing them into boost:: as
1.680 +// necessary.
1.681 +//
1.682 +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
1.683 +
1.684 +// is_chained_base<> - a traits class used to distinguish whether an operator
1.685 +// template argument is being used for base class chaining, or is specifying a
1.686 +// 2nd argument type.
1.687 +
1.688 +namespace boost {
1.689 +// A type parameter is used instead of a plain bool because Borland's compiler
1.690 +// didn't cope well with the more obvious non-type template parameter.
1.691 +namespace detail {
1.692 + struct true_t {};
1.693 + struct false_t {};
1.694 +} // namespace detail
1.695 +
1.696 +// Unspecialized version assumes that most types are not being used for base
1.697 +// class chaining. We specialize for the operator templates defined in this
1.698 +// library.
1.699 +template<class T> struct is_chained_base {
1.700 + typedef ::boost::detail::false_t value;
1.701 +};
1.702 +
1.703 +} // namespace boost
1.704 +
1.705 +// Import a 4-type-argument operator template into boost (if necessary) and
1.706 +// provide a specialization of 'is_chained_base<>' for it.
1.707 +# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
1.708 + BOOST_IMPORT_TEMPLATE4(template_name4) \
1.709 + template<class T, class U, class V, class W, class B> \
1.710 + struct is_chained_base< ::boost::template_name4<T, U, V, W, B> > { \
1.711 + typedef ::boost::detail::true_t value; \
1.712 + };
1.713 +
1.714 +// Import a 3-type-argument operator template into boost (if necessary) and
1.715 +// provide a specialization of 'is_chained_base<>' for it.
1.716 +# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
1.717 + BOOST_IMPORT_TEMPLATE3(template_name3) \
1.718 + template<class T, class U, class V, class B> \
1.719 + struct is_chained_base< ::boost::template_name3<T, U, V, B> > { \
1.720 + typedef ::boost::detail::true_t value; \
1.721 + };
1.722 +
1.723 +// Import a 2-type-argument operator template into boost (if necessary) and
1.724 +// provide a specialization of 'is_chained_base<>' for it.
1.725 +# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
1.726 + BOOST_IMPORT_TEMPLATE2(template_name2) \
1.727 + template<class T, class U, class B> \
1.728 + struct is_chained_base< ::boost::template_name2<T, U, B> > { \
1.729 + typedef ::boost::detail::true_t value; \
1.730 + };
1.731 +
1.732 +// Import a 1-type-argument operator template into boost (if necessary) and
1.733 +// provide a specialization of 'is_chained_base<>' for it.
1.734 +# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
1.735 + BOOST_IMPORT_TEMPLATE1(template_name1) \
1.736 + template<class T, class B> \
1.737 + struct is_chained_base< ::boost::template_name1<T, B> > { \
1.738 + typedef ::boost::detail::true_t value; \
1.739 + };
1.740 +
1.741 +// BOOST_OPERATOR_TEMPLATE(template_name) defines template_name<> such that it
1.742 +// can be used for specifying both 1-argument and 2-argument forms. Requires the
1.743 +// existence of two previously defined class templates named '<template_name>1'
1.744 +// and '<template_name>2' which must implement the corresponding 1- and 2-
1.745 +// argument forms.
1.746 +//
1.747 +// The template type parameter O == is_chained_base<U>::value is used to
1.748 +// distinguish whether the 2nd argument to <template_name> is being used for
1.749 +// base class chaining from another boost operator template or is describing a
1.750 +// 2nd operand type. O == true_t only when U is actually an another operator
1.751 +// template from the library. Partial specialization is used to select an
1.752 +// implementation in terms of either '<template_name>1' or '<template_name>2'.
1.753 +//
1.754 +
1.755 +# define BOOST_OPERATOR_TEMPLATE(template_name) \
1.756 +template <class T \
1.757 + ,class U = T \
1.758 + ,class B = ::boost::detail::empty_base \
1.759 + ,class O = typename is_chained_base<U>::value \
1.760 + > \
1.761 +struct template_name : template_name##2<T, U, B> {}; \
1.762 + \
1.763 +template<class T, class U, class B> \
1.764 +struct template_name<T, U, B, ::boost::detail::true_t> \
1.765 + : template_name##1<T, U> {}; \
1.766 + \
1.767 +template <class T, class B> \
1.768 +struct template_name<T, T, B, ::boost::detail::false_t> \
1.769 + : template_name##1<T, B> {}; \
1.770 + \
1.771 +template<class T, class U, class B, class O> \
1.772 +struct is_chained_base< ::boost::template_name<T, U, B, O> > { \
1.773 + typedef ::boost::detail::true_t value; \
1.774 +}; \
1.775 + \
1.776 +BOOST_OPERATOR_TEMPLATE2(template_name##2) \
1.777 +BOOST_OPERATOR_TEMPLATE1(template_name##1)
1.778 +
1.779 +
1.780 +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
1.781 +
1.782 +# define BOOST_OPERATOR_TEMPLATE4(template_name4) \
1.783 + BOOST_IMPORT_TEMPLATE4(template_name4)
1.784 +# define BOOST_OPERATOR_TEMPLATE3(template_name3) \
1.785 + BOOST_IMPORT_TEMPLATE3(template_name3)
1.786 +# define BOOST_OPERATOR_TEMPLATE2(template_name2) \
1.787 + BOOST_IMPORT_TEMPLATE2(template_name2)
1.788 +# define BOOST_OPERATOR_TEMPLATE1(template_name1) \
1.789 + BOOST_IMPORT_TEMPLATE1(template_name1)
1.790 +
1.791 + // In this case we can only assume that template_name<> is equivalent to the
1.792 + // more commonly needed template_name1<> form.
1.793 +# define BOOST_OPERATOR_TEMPLATE(template_name) \
1.794 + template <class T, class B = ::boost::detail::empty_base> \
1.795 + struct template_name : template_name##1<T, B> {};
1.796 +
1.797 +#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
1.798 +
1.799 +namespace boost {
1.800 +
1.801 +BOOST_OPERATOR_TEMPLATE(less_than_comparable)
1.802 +BOOST_OPERATOR_TEMPLATE(equality_comparable)
1.803 +BOOST_OPERATOR_TEMPLATE(multipliable)
1.804 +BOOST_OPERATOR_TEMPLATE(addable)
1.805 +BOOST_OPERATOR_TEMPLATE(subtractable)
1.806 +BOOST_OPERATOR_TEMPLATE2(subtractable2_left)
1.807 +BOOST_OPERATOR_TEMPLATE(dividable)
1.808 +BOOST_OPERATOR_TEMPLATE2(dividable2_left)
1.809 +BOOST_OPERATOR_TEMPLATE(modable)
1.810 +BOOST_OPERATOR_TEMPLATE2(modable2_left)
1.811 +BOOST_OPERATOR_TEMPLATE(xorable)
1.812 +BOOST_OPERATOR_TEMPLATE(andable)
1.813 +BOOST_OPERATOR_TEMPLATE(orable)
1.814 +
1.815 +BOOST_OPERATOR_TEMPLATE1(incrementable)
1.816 +BOOST_OPERATOR_TEMPLATE1(decrementable)
1.817 +
1.818 +BOOST_OPERATOR_TEMPLATE2(dereferenceable)
1.819 +BOOST_OPERATOR_TEMPLATE3(indexable)
1.820 +
1.821 +BOOST_OPERATOR_TEMPLATE(left_shiftable)
1.822 +BOOST_OPERATOR_TEMPLATE(right_shiftable)
1.823 +BOOST_OPERATOR_TEMPLATE(equivalent)
1.824 +BOOST_OPERATOR_TEMPLATE(partially_ordered)
1.825 +
1.826 +BOOST_OPERATOR_TEMPLATE(totally_ordered)
1.827 +BOOST_OPERATOR_TEMPLATE(additive)
1.828 +BOOST_OPERATOR_TEMPLATE(multiplicative)
1.829 +BOOST_OPERATOR_TEMPLATE(integer_multiplicative)
1.830 +BOOST_OPERATOR_TEMPLATE(arithmetic)
1.831 +BOOST_OPERATOR_TEMPLATE(integer_arithmetic)
1.832 +BOOST_OPERATOR_TEMPLATE(bitwise)
1.833 +BOOST_OPERATOR_TEMPLATE1(unit_steppable)
1.834 +BOOST_OPERATOR_TEMPLATE(shiftable)
1.835 +BOOST_OPERATOR_TEMPLATE(ring_operators)
1.836 +BOOST_OPERATOR_TEMPLATE(ordered_ring_operators)
1.837 +BOOST_OPERATOR_TEMPLATE(field_operators)
1.838 +BOOST_OPERATOR_TEMPLATE(ordered_field_operators)
1.839 +BOOST_OPERATOR_TEMPLATE(euclidian_ring_operators)
1.840 +BOOST_OPERATOR_TEMPLATE(ordered_euclidian_ring_operators)
1.841 +BOOST_OPERATOR_TEMPLATE2(input_iteratable)
1.842 +BOOST_OPERATOR_TEMPLATE1(output_iteratable)
1.843 +BOOST_OPERATOR_TEMPLATE2(forward_iteratable)
1.844 +BOOST_OPERATOR_TEMPLATE2(bidirectional_iteratable)
1.845 +BOOST_OPERATOR_TEMPLATE4(random_access_iteratable)
1.846 +
1.847 +#undef BOOST_OPERATOR_TEMPLATE
1.848 +#undef BOOST_OPERATOR_TEMPLATE4
1.849 +#undef BOOST_OPERATOR_TEMPLATE3
1.850 +#undef BOOST_OPERATOR_TEMPLATE2
1.851 +#undef BOOST_OPERATOR_TEMPLATE1
1.852 +#undef BOOST_IMPORT_TEMPLATE1
1.853 +#undef BOOST_IMPORT_TEMPLATE2
1.854 +#undef BOOST_IMPORT_TEMPLATE3
1.855 +#undef BOOST_IMPORT_TEMPLATE4
1.856 +
1.857 +// The following 'operators' classes can only be used portably if the derived class
1.858 +// declares ALL of the required member operators.
1.859 +template <class T, class U>
1.860 +struct operators2
1.861 + : totally_ordered2<T,U
1.862 + , integer_arithmetic2<T,U
1.863 + , bitwise2<T,U
1.864 + > > > {};
1.865 +
1.866 +#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
1.867 +template <class T, class U = T>
1.868 +struct operators : operators2<T, U> {};
1.869 +
1.870 +template <class T> struct operators<T, T>
1.871 +#else
1.872 +template <class T> struct operators
1.873 +#endif
1.874 + : totally_ordered<T
1.875 + , integer_arithmetic<T
1.876 + , bitwise<T
1.877 + , unit_steppable<T
1.878 + > > > > {};
1.879 +
1.880 +// Iterator helper classes (contributed by Jeremy Siek) -------------------//
1.881 +// (Input and output iterator helpers contributed by Daryle Walker) -------//
1.882 +// (Changed to use combined operator classes by Daryle Walker) ------------//
1.883 +template <class T,
1.884 + class V,
1.885 + class D = std::ptrdiff_t,
1.886 + class P = V const *,
1.887 + class R = V const &>
1.888 +struct input_iterator_helper
1.889 + : input_iteratable<T, P
1.890 + , boost::iterator<std::input_iterator_tag, V, D, P, R
1.891 + > > {};
1.892 +
1.893 +template<class T>
1.894 +struct output_iterator_helper
1.895 + : output_iteratable<T
1.896 + , boost::iterator<std::output_iterator_tag, void, void, void, void
1.897 + > >
1.898 +{
1.899 + T& operator*() { return static_cast<T&>(*this); }
1.900 + T& operator++() { return static_cast<T&>(*this); }
1.901 +};
1.902 +
1.903 +template <class T,
1.904 + class V,
1.905 + class D = std::ptrdiff_t,
1.906 + class P = V*,
1.907 + class R = V&>
1.908 +struct forward_iterator_helper
1.909 + : forward_iteratable<T, P
1.910 + , boost::iterator<std::forward_iterator_tag, V, D, P, R
1.911 + > > {};
1.912 +
1.913 +template <class T,
1.914 + class V,
1.915 + class D = std::ptrdiff_t,
1.916 + class P = V*,
1.917 + class R = V&>
1.918 +struct bidirectional_iterator_helper
1.919 + : bidirectional_iteratable<T, P
1.920 + , boost::iterator<std::bidirectional_iterator_tag, V, D, P, R
1.921 + > > {};
1.922 +
1.923 +template <class T,
1.924 + class V,
1.925 + class D = std::ptrdiff_t,
1.926 + class P = V*,
1.927 + class R = V&>
1.928 +struct random_access_iterator_helper
1.929 + : random_access_iteratable<T, P, D, R
1.930 + , boost::iterator<std::random_access_iterator_tag, V, D, P, R
1.931 + > >
1.932 +{
1.933 + friend D requires_difference_operator(const T& x, const T& y) {
1.934 + return x - y;
1.935 + }
1.936 +}; // random_access_iterator_helper
1.937 +
1.938 +} // namespace boost
1.939 +
1.940 +#if defined(__sgi) && !defined(__GNUC__)
1.941 +#pragma reset woff 1234
1.942 +#endif
1.943 +
1.944 +#endif // BOOST_OPERATORS_HPP