1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/epoc32/include/stdapis/boost/tuple/detail/tuple_basic.hpp Tue Mar 16 16:12:26 2010 +0000
1.3 @@ -0,0 +1,944 @@
1.4 +// tuple_basic.hpp -----------------------------------------------------
1.5 +
1.6 +// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
1.7 +//
1.8 +// Distributed under the Boost Software License, Version 1.0. (See
1.9 +// accompanying file LICENSE_1_0.txt or copy at
1.10 +// http://www.boost.org/LICENSE_1_0.txt)
1.11 +
1.12 +// For more information, see http://www.boost.org
1.13 +
1.14 +// Outside help:
1.15 +// This and that, Gary Powell.
1.16 +// Fixed return types for get_head/get_tail
1.17 +// ( and other bugs ) per suggestion of Jens Maurer
1.18 +// simplified element type accessors + bug fix (Jeremy Siek)
1.19 +// Several changes/additions according to suggestions by Douglas Gregor,
1.20 +// William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes,
1.21 +// David Abrahams.
1.22 +
1.23 +// Revision history:
1.24 +// 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes
1.25 +// 2002 04 18 Jaakko: tuple element types can be void or plain function
1.26 +// types, as long as no object is created.
1.27 +// Tuple objects can no hold even noncopyable types
1.28 +// such as arrays.
1.29 +// 2001 10 22 John Maddock
1.30 +// Fixes for Borland C++
1.31 +// 2001 08 30 David Abrahams
1.32 +// Added default constructor for cons<>.
1.33 +// -----------------------------------------------------------------
1.34 +
1.35 +#ifndef BOOST_TUPLE_BASIC_HPP
1.36 +#define BOOST_TUPLE_BASIC_HPP
1.37 +
1.38 +
1.39 +#include <utility> // needed for the assignment from pair to tuple
1.40 +
1.41 +#include "boost/type_traits/cv_traits.hpp"
1.42 +#include "boost/type_traits/function_traits.hpp"
1.43 +
1.44 +#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
1.45 +
1.46 +namespace boost {
1.47 +namespace tuples {
1.48 +
1.49 +// -- null_type --------------------------------------------------------
1.50 +struct null_type {};
1.51 +
1.52 +// a helper function to provide a const null_type type temporary
1.53 +namespace detail {
1.54 + inline const null_type cnull() { return null_type(); }
1.55 +
1.56 +
1.57 +// -- if construct ------------------------------------------------
1.58 +// Proposed by Krzysztof Czarnecki and Ulrich Eisenecker
1.59 +
1.60 +template <bool If, class Then, class Else> struct IF { typedef Then RET; };
1.61 +
1.62 +template <class Then, class Else> struct IF<false, Then, Else> {
1.63 + typedef Else RET;
1.64 +};
1.65 +
1.66 +} // end detail
1.67 +
1.68 +// - cons forward declaration -----------------------------------------------
1.69 +template <class HT, class TT> struct cons;
1.70 +
1.71 +
1.72 +// - tuple forward declaration -----------------------------------------------
1.73 +template <
1.74 + class T0 = null_type, class T1 = null_type, class T2 = null_type,
1.75 + class T3 = null_type, class T4 = null_type, class T5 = null_type,
1.76 + class T6 = null_type, class T7 = null_type, class T8 = null_type,
1.77 + class T9 = null_type>
1.78 +class tuple;
1.79 +
1.80 +// tuple_length forward declaration
1.81 +template<class T> struct length;
1.82 +
1.83 +
1.84 +
1.85 +namespace detail {
1.86 +
1.87 +// -- generate error template, referencing to non-existing members of this
1.88 +// template is used to produce compilation errors intentionally
1.89 +template<class T>
1.90 +class generate_error;
1.91 +
1.92 +// - cons getters --------------------------------------------------------
1.93 +// called: get_class<N>::get<RETURN_TYPE>(aTuple)
1.94 +
1.95 +template< int N >
1.96 +struct get_class {
1.97 + template<class RET, class HT, class TT >
1.98 + inline static RET get(const cons<HT, TT>& t)
1.99 + {
1.100 +#if BOOST_WORKAROUND(__IBMCPP__,==600)
1.101 + // vacpp 6.0 is not very consistent regarding the member template keyword
1.102 + // Here it generates an error when the template keyword is used.
1.103 + return get_class<N-1>::get<RET>(t.tail);
1.104 +#else
1.105 + return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
1.106 +#endif
1.107 + }
1.108 + template<class RET, class HT, class TT >
1.109 + inline static RET get(cons<HT, TT>& t)
1.110 + {
1.111 +#if BOOST_WORKAROUND(__IBMCPP__,==600)
1.112 + return get_class<N-1>::get<RET>(t.tail);
1.113 +#else
1.114 + return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail);
1.115 +#endif
1.116 + }
1.117 +};
1.118 +
1.119 +template<>
1.120 +struct get_class<0> {
1.121 + template<class RET, class HT, class TT>
1.122 + inline static RET get(const cons<HT, TT>& t)
1.123 + {
1.124 + return t.head;
1.125 + }
1.126 + template<class RET, class HT, class TT>
1.127 + inline static RET get(cons<HT, TT>& t)
1.128 + {
1.129 + return t.head;
1.130 + }
1.131 +};
1.132 +
1.133 +} // end of namespace detail
1.134 +
1.135 +
1.136 +// -cons type accessors ----------------------------------------
1.137 +// typename tuples::element<N,T>::type gets the type of the
1.138 +// Nth element ot T, first element is at index 0
1.139 +// -------------------------------------------------------
1.140 +
1.141 +#ifndef BOOST_NO_CV_SPECIALIZATIONS
1.142 +
1.143 +template<int N, class T>
1.144 +struct element
1.145 +{
1.146 +private:
1.147 + typedef typename T::tail_type Next;
1.148 +public:
1.149 + typedef typename element<N-1, Next>::type type;
1.150 +};
1.151 +template<class T>
1.152 +struct element<0,T>
1.153 +{
1.154 + typedef typename T::head_type type;
1.155 +};
1.156 +
1.157 +template<int N, class T>
1.158 +struct element<N, const T>
1.159 +{
1.160 +private:
1.161 + typedef typename T::tail_type Next;
1.162 + typedef typename element<N-1, Next>::type unqualified_type;
1.163 +public:
1.164 +#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
1.165 + typedef const unqualified_type type;
1.166 +#else
1.167 + typedef typename boost::add_const<unqualified_type>::type type;
1.168 +#endif
1.169 +
1.170 +};
1.171 +template<class T>
1.172 +struct element<0,const T>
1.173 +{
1.174 +#if BOOST_WORKAROUND(__BORLANDC__,<0x600)
1.175 + typedef const typename T::head_type type;
1.176 +#else
1.177 + typedef typename boost::add_const<typename T::head_type>::type type;
1.178 +#endif
1.179 +};
1.180 +
1.181 +#else // def BOOST_NO_CV_SPECIALIZATIONS
1.182 +
1.183 +namespace detail {
1.184 +
1.185 +template<int N, class T, bool IsConst>
1.186 +struct element_impl
1.187 +{
1.188 +private:
1.189 + typedef typename T::tail_type Next;
1.190 +public:
1.191 + typedef typename element_impl<N-1, Next, IsConst>::type type;
1.192 +};
1.193 +
1.194 +template<int N, class T>
1.195 +struct element_impl<N, T, true /* IsConst */>
1.196 +{
1.197 +private:
1.198 + typedef typename T::tail_type Next;
1.199 +public:
1.200 + typedef const typename element_impl<N-1, Next, true>::type type;
1.201 +};
1.202 +
1.203 +template<class T>
1.204 +struct element_impl<0, T, false /* IsConst */>
1.205 +{
1.206 + typedef typename T::head_type type;
1.207 +};
1.208 +
1.209 +template<class T>
1.210 +struct element_impl<0, T, true /* IsConst */>
1.211 +{
1.212 + typedef const typename T::head_type type;
1.213 +};
1.214 +
1.215 +} // end of namespace detail
1.216 +
1.217 +
1.218 +template<int N, class T>
1.219 +struct element:
1.220 + public detail::element_impl<N, T, ::boost::is_const<T>::value>
1.221 +{
1.222 +};
1.223 +
1.224 +#endif
1.225 +
1.226 +
1.227 +// -get function templates -----------------------------------------------
1.228 +// Usage: get<N>(aTuple)
1.229 +
1.230 +// -- some traits classes for get functions
1.231 +
1.232 +// access traits lifted from detail namespace to be part of the interface,
1.233 +// (Joel de Guzman's suggestion). Rationale: get functions are part of the
1.234 +// interface, so should the way to express their return types be.
1.235 +
1.236 +template <class T> struct access_traits {
1.237 + typedef const T& const_type;
1.238 + typedef T& non_const_type;
1.239 +
1.240 + typedef const typename boost::remove_cv<T>::type& parameter_type;
1.241 +
1.242 +// used as the tuple constructors parameter types
1.243 +// Rationale: non-reference tuple element types can be cv-qualified.
1.244 +// It should be possible to initialize such types with temporaries,
1.245 +// and when binding temporaries to references, the reference must
1.246 +// be non-volatile and const. 8.5.3. (5)
1.247 +};
1.248 +
1.249 +template <class T> struct access_traits<T&> {
1.250 +
1.251 + typedef T& const_type;
1.252 + typedef T& non_const_type;
1.253 +
1.254 + typedef T& parameter_type;
1.255 +};
1.256 +
1.257 +// get function for non-const cons-lists, returns a reference to the element
1.258 +
1.259 +template<int N, class HT, class TT>
1.260 +inline typename access_traits<
1.261 + typename element<N, cons<HT, TT> >::type
1.262 + >::non_const_type
1.263 +get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
1.264 +#if BOOST_WORKAROUND(__IBMCPP__,==600 )
1.265 + return detail::get_class<N>::
1.266 +#else
1.267 + return detail::get_class<N>::BOOST_NESTED_TEMPLATE
1.268 +#endif
1.269 + get<
1.270 + typename access_traits<
1.271 + typename element<N, cons<HT, TT> >::type
1.272 + >::non_const_type,
1.273 + HT,TT
1.274 + >(c);
1.275 +}
1.276 +
1.277 +// get function for const cons-lists, returns a const reference to
1.278 +// the element. If the element is a reference, returns the reference
1.279 +// as such (that is, can return a non-const reference)
1.280 +template<int N, class HT, class TT>
1.281 +inline typename access_traits<
1.282 + typename element<N, cons<HT, TT> >::type
1.283 + >::const_type
1.284 +get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
1.285 +#if BOOST_WORKAROUND(__IBMCPP__,==600)
1.286 + return detail::get_class<N>::
1.287 +#else
1.288 + return detail::get_class<N>::BOOST_NESTED_TEMPLATE
1.289 +#endif
1.290 + get<
1.291 + typename access_traits<
1.292 + typename element<N, cons<HT, TT> >::type
1.293 + >::const_type,
1.294 + HT,TT
1.295 + >(c);
1.296 +}
1.297 +
1.298 +// -- the cons template --------------------------------------------------
1.299 +namespace detail {
1.300 +
1.301 +// These helper templates wrap void types and plain function types.
1.302 +// The reationale is to allow one to write tuple types with those types
1.303 +// as elements, even though it is not possible to instantiate such object.
1.304 +// E.g: typedef tuple<void> some_type; // ok
1.305 +// but: some_type x; // fails
1.306 +
1.307 +template <class T> class non_storeable_type {
1.308 + non_storeable_type();
1.309 +};
1.310 +
1.311 +template <class T> struct wrap_non_storeable_type {
1.312 + typedef typename IF<
1.313 + ::boost::is_function<T>::value, non_storeable_type<T>, T
1.314 + >::RET type;
1.315 +};
1.316 +template <> struct wrap_non_storeable_type<void> {
1.317 + typedef non_storeable_type<void> type;
1.318 +};
1.319 +
1.320 +} // detail
1.321 +
1.322 +template <class HT, class TT>
1.323 +struct cons {
1.324 +
1.325 + typedef HT head_type;
1.326 + typedef TT tail_type;
1.327 +
1.328 + typedef typename
1.329 + detail::wrap_non_storeable_type<head_type>::type stored_head_type;
1.330 +
1.331 + stored_head_type head;
1.332 + tail_type tail;
1.333 +
1.334 + typename access_traits<stored_head_type>::non_const_type
1.335 + get_head() { return head; }
1.336 +
1.337 + typename access_traits<tail_type>::non_const_type
1.338 + get_tail() { return tail; }
1.339 +
1.340 + typename access_traits<stored_head_type>::const_type
1.341 + get_head() const { return head; }
1.342 +
1.343 + typename access_traits<tail_type>::const_type
1.344 + get_tail() const { return tail; }
1.345 +
1.346 + cons() : head(), tail() {}
1.347 + // cons() : head(detail::default_arg<HT>::f()), tail() {}
1.348 +
1.349 + // the argument for head is not strictly needed, but it prevents
1.350 + // array type elements. This is good, since array type elements
1.351 + // cannot be supported properly in any case (no assignment,
1.352 + // copy works only if the tails are exactly the same type, ...)
1.353 +
1.354 + cons(typename access_traits<stored_head_type>::parameter_type h,
1.355 + const tail_type& t)
1.356 + : head (h), tail(t) {}
1.357 +
1.358 + template <class T1, class T2, class T3, class T4, class T5,
1.359 + class T6, class T7, class T8, class T9, class T10>
1.360 + cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5,
1.361 + T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
1.362 + : head (t1),
1.363 + tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
1.364 + {}
1.365 +
1.366 + template <class T2, class T3, class T4, class T5,
1.367 + class T6, class T7, class T8, class T9, class T10>
1.368 + cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5,
1.369 + T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 )
1.370 + : head (),
1.371 + tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull())
1.372 + {}
1.373 +
1.374 +
1.375 + template <class HT2, class TT2>
1.376 + cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
1.377 +
1.378 + template <class HT2, class TT2>
1.379 + cons& operator=( const cons<HT2, TT2>& u ) {
1.380 + head=u.head; tail=u.tail; return *this;
1.381 + }
1.382 +
1.383 + // must define assignment operator explicitly, implicit version is
1.384 + // illformed if HT is a reference (12.8. (12))
1.385 + cons& operator=(const cons& u) {
1.386 + head = u.head; tail = u.tail; return *this;
1.387 + }
1.388 +
1.389 + template <class T1, class T2>
1.390 + cons& operator=( const std::pair<T1, T2>& u ) {
1.391 + BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2
1.392 + head = u.first; tail.head = u.second; return *this;
1.393 + }
1.394 +
1.395 + // get member functions (non-const and const)
1.396 + template <int N>
1.397 + typename access_traits<
1.398 + typename element<N, cons<HT, TT> >::type
1.399 + >::non_const_type
1.400 + get() {
1.401 + return boost::tuples::get<N>(*this); // delegate to non-member get
1.402 + }
1.403 +
1.404 + template <int N>
1.405 + typename access_traits<
1.406 + typename element<N, cons<HT, TT> >::type
1.407 + >::const_type
1.408 + get() const {
1.409 + return boost::tuples::get<N>(*this); // delegate to non-member get
1.410 + }
1.411 +};
1.412 +
1.413 +template <class HT>
1.414 +struct cons<HT, null_type> {
1.415 +
1.416 + typedef HT head_type;
1.417 + typedef null_type tail_type;
1.418 + typedef cons<HT, null_type> self_type;
1.419 +
1.420 + typedef typename
1.421 + detail::wrap_non_storeable_type<head_type>::type stored_head_type;
1.422 + stored_head_type head;
1.423 +
1.424 + typename access_traits<stored_head_type>::non_const_type
1.425 + get_head() { return head; }
1.426 +
1.427 + null_type get_tail() { return null_type(); }
1.428 +
1.429 + typename access_traits<stored_head_type>::const_type
1.430 + get_head() const { return head; }
1.431 +
1.432 + const null_type get_tail() const { return null_type(); }
1.433 +
1.434 + // cons() : head(detail::default_arg<HT>::f()) {}
1.435 + cons() : head() {}
1.436 +
1.437 + cons(typename access_traits<stored_head_type>::parameter_type h,
1.438 + const null_type& = null_type())
1.439 + : head (h) {}
1.440 +
1.441 + template<class T1>
1.442 + cons(T1& t1, const null_type&, const null_type&, const null_type&,
1.443 + const null_type&, const null_type&, const null_type&,
1.444 + const null_type&, const null_type&, const null_type&)
1.445 + : head (t1) {}
1.446 +
1.447 + cons(const null_type&,
1.448 + const null_type&, const null_type&, const null_type&,
1.449 + const null_type&, const null_type&, const null_type&,
1.450 + const null_type&, const null_type&, const null_type&)
1.451 + : head () {}
1.452 +
1.453 + template <class HT2>
1.454 + cons( const cons<HT2, null_type>& u ) : head(u.head) {}
1.455 +
1.456 + template <class HT2>
1.457 + cons& operator=(const cons<HT2, null_type>& u )
1.458 + { head = u.head; return *this; }
1.459 +
1.460 + // must define assignment operator explicitely, implicit version
1.461 + // is illformed if HT is a reference
1.462 + cons& operator=(const cons& u) { head = u.head; return *this; }
1.463 +
1.464 + template <int N>
1.465 + typename access_traits<
1.466 + typename element<N, self_type>::type
1.467 + >::non_const_type
1.468 + get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
1.469 + return boost::tuples::get<N>(*this);
1.470 + }
1.471 +
1.472 + template <int N>
1.473 + typename access_traits<
1.474 + typename element<N, self_type>::type
1.475 + >::const_type
1.476 + get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
1.477 + return boost::tuples::get<N>(*this);
1.478 + }
1.479 +
1.480 +};
1.481 +
1.482 +// templates for finding out the length of the tuple -------------------
1.483 +
1.484 +template<class T>
1.485 +struct length {
1.486 + BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value);
1.487 +};
1.488 +
1.489 +template<>
1.490 +struct length<tuple<> > {
1.491 + BOOST_STATIC_CONSTANT(int, value = 0);
1.492 +};
1.493 +
1.494 +template<>
1.495 +struct length<null_type> {
1.496 + BOOST_STATIC_CONSTANT(int, value = 0);
1.497 +};
1.498 +
1.499 +
1.500 +namespace detail {
1.501 +
1.502 +// Tuple to cons mapper --------------------------------------------------
1.503 +template <class T0, class T1, class T2, class T3, class T4,
1.504 + class T5, class T6, class T7, class T8, class T9>
1.505 +struct map_tuple_to_cons
1.506 +{
1.507 + typedef cons<T0,
1.508 + typename map_tuple_to_cons<T1, T2, T3, T4, T5,
1.509 + T6, T7, T8, T9, null_type>::type
1.510 + > type;
1.511 +};
1.512 +
1.513 +// The empty tuple is a null_type
1.514 +template <>
1.515 +struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type>
1.516 +{
1.517 + typedef null_type type;
1.518 +};
1.519 +
1.520 +} // end detail
1.521 +
1.522 +// -------------------------------------------------------------------
1.523 +// -- tuple ------------------------------------------------------
1.524 +template <class T0, class T1, class T2, class T3, class T4,
1.525 + class T5, class T6, class T7, class T8, class T9>
1.526 +
1.527 +class tuple :
1.528 + public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
1.529 +{
1.530 +public:
1.531 + typedef typename
1.532 + detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited;
1.533 + typedef typename inherited::head_type head_type;
1.534 + typedef typename inherited::tail_type tail_type;
1.535 +
1.536 +
1.537 +// access_traits<T>::parameter_type takes non-reference types as const T&
1.538 + tuple() {}
1.539 +
1.540 + tuple(typename access_traits<T0>::parameter_type t0)
1.541 + : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(),
1.542 + detail::cnull(), detail::cnull(), detail::cnull(),
1.543 + detail::cnull(), detail::cnull(), detail::cnull()) {}
1.544 +
1.545 + tuple(typename access_traits<T0>::parameter_type t0,
1.546 + typename access_traits<T1>::parameter_type t1)
1.547 + : inherited(t0, t1, detail::cnull(), detail::cnull(),
1.548 + detail::cnull(), detail::cnull(), detail::cnull(),
1.549 + detail::cnull(), detail::cnull(), detail::cnull()) {}
1.550 +
1.551 + tuple(typename access_traits<T0>::parameter_type t0,
1.552 + typename access_traits<T1>::parameter_type t1,
1.553 + typename access_traits<T2>::parameter_type t2)
1.554 + : inherited(t0, t1, t2, detail::cnull(), detail::cnull(),
1.555 + detail::cnull(), detail::cnull(), detail::cnull(),
1.556 + detail::cnull(), detail::cnull()) {}
1.557 +
1.558 + tuple(typename access_traits<T0>::parameter_type t0,
1.559 + typename access_traits<T1>::parameter_type t1,
1.560 + typename access_traits<T2>::parameter_type t2,
1.561 + typename access_traits<T3>::parameter_type t3)
1.562 + : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(),
1.563 + detail::cnull(), detail::cnull(), detail::cnull(),
1.564 + detail::cnull()) {}
1.565 +
1.566 + tuple(typename access_traits<T0>::parameter_type t0,
1.567 + typename access_traits<T1>::parameter_type t1,
1.568 + typename access_traits<T2>::parameter_type t2,
1.569 + typename access_traits<T3>::parameter_type t3,
1.570 + typename access_traits<T4>::parameter_type t4)
1.571 + : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(),
1.572 + detail::cnull(), detail::cnull(), detail::cnull()) {}
1.573 +
1.574 + tuple(typename access_traits<T0>::parameter_type t0,
1.575 + typename access_traits<T1>::parameter_type t1,
1.576 + typename access_traits<T2>::parameter_type t2,
1.577 + typename access_traits<T3>::parameter_type t3,
1.578 + typename access_traits<T4>::parameter_type t4,
1.579 + typename access_traits<T5>::parameter_type t5)
1.580 + : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(),
1.581 + detail::cnull(), detail::cnull()) {}
1.582 +
1.583 + tuple(typename access_traits<T0>::parameter_type t0,
1.584 + typename access_traits<T1>::parameter_type t1,
1.585 + typename access_traits<T2>::parameter_type t2,
1.586 + typename access_traits<T3>::parameter_type t3,
1.587 + typename access_traits<T4>::parameter_type t4,
1.588 + typename access_traits<T5>::parameter_type t5,
1.589 + typename access_traits<T6>::parameter_type t6)
1.590 + : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(),
1.591 + detail::cnull(), detail::cnull()) {}
1.592 +
1.593 + tuple(typename access_traits<T0>::parameter_type t0,
1.594 + typename access_traits<T1>::parameter_type t1,
1.595 + typename access_traits<T2>::parameter_type t2,
1.596 + typename access_traits<T3>::parameter_type t3,
1.597 + typename access_traits<T4>::parameter_type t4,
1.598 + typename access_traits<T5>::parameter_type t5,
1.599 + typename access_traits<T6>::parameter_type t6,
1.600 + typename access_traits<T7>::parameter_type t7)
1.601 + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(),
1.602 + detail::cnull()) {}
1.603 +
1.604 + tuple(typename access_traits<T0>::parameter_type t0,
1.605 + typename access_traits<T1>::parameter_type t1,
1.606 + typename access_traits<T2>::parameter_type t2,
1.607 + typename access_traits<T3>::parameter_type t3,
1.608 + typename access_traits<T4>::parameter_type t4,
1.609 + typename access_traits<T5>::parameter_type t5,
1.610 + typename access_traits<T6>::parameter_type t6,
1.611 + typename access_traits<T7>::parameter_type t7,
1.612 + typename access_traits<T8>::parameter_type t8)
1.613 + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {}
1.614 +
1.615 + tuple(typename access_traits<T0>::parameter_type t0,
1.616 + typename access_traits<T1>::parameter_type t1,
1.617 + typename access_traits<T2>::parameter_type t2,
1.618 + typename access_traits<T3>::parameter_type t3,
1.619 + typename access_traits<T4>::parameter_type t4,
1.620 + typename access_traits<T5>::parameter_type t5,
1.621 + typename access_traits<T6>::parameter_type t6,
1.622 + typename access_traits<T7>::parameter_type t7,
1.623 + typename access_traits<T8>::parameter_type t8,
1.624 + typename access_traits<T9>::parameter_type t9)
1.625 + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {}
1.626 +
1.627 +
1.628 + template<class U1, class U2>
1.629 + tuple(const cons<U1, U2>& p) : inherited(p) {}
1.630 +
1.631 + template <class U1, class U2>
1.632 + tuple& operator=(const cons<U1, U2>& k) {
1.633 + inherited::operator=(k);
1.634 + return *this;
1.635 + }
1.636 +
1.637 + template <class U1, class U2>
1.638 + tuple& operator=(const std::pair<U1, U2>& k) {
1.639 + BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2
1.640 + this->head = k.first;
1.641 + this->tail.head = k.second;
1.642 + return *this;
1.643 + }
1.644 +
1.645 +};
1.646 +
1.647 +// The empty tuple
1.648 +template <>
1.649 +class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> :
1.650 + public null_type
1.651 +{
1.652 +public:
1.653 + typedef null_type inherited;
1.654 +};
1.655 +
1.656 +
1.657 +// Swallows any assignment (by Doug Gregor)
1.658 +namespace detail {
1.659 +
1.660 +struct swallow_assign {
1.661 +
1.662 + template<typename T>
1.663 + swallow_assign const& operator=(const T&) const {
1.664 + return *this;
1.665 + }
1.666 +};
1.667 +
1.668 +} // namespace detail
1.669 +
1.670 +// "ignore" allows tuple positions to be ignored when using "tie".
1.671 +detail::swallow_assign const ignore = detail::swallow_assign();
1.672 +
1.673 +// ---------------------------------------------------------------------------
1.674 +// The call_traits for make_tuple
1.675 +// Honours the reference_wrapper class.
1.676 +
1.677 +// Must be instantiated with plain or const plain types (not with references)
1.678 +
1.679 +// from template<class T> foo(const T& t) : make_tuple_traits<const T>::type
1.680 +// from template<class T> foo(T& t) : make_tuple_traits<T>::type
1.681 +
1.682 +// Conversions:
1.683 +// T -> T,
1.684 +// references -> compile_time_error
1.685 +// reference_wrapper<T> -> T&
1.686 +// const reference_wrapper<T> -> T&
1.687 +// array -> const ref array
1.688 +
1.689 +
1.690 +template<class T>
1.691 +struct make_tuple_traits {
1.692 + typedef T type;
1.693 +
1.694 + // commented away, see below (JJ)
1.695 + // typedef typename IF<
1.696 + // boost::is_function<T>::value,
1.697 + // T&,
1.698 + // T>::RET type;
1.699 +
1.700 +};
1.701 +
1.702 +// The is_function test was there originally for plain function types,
1.703 +// which can't be stored as such (we must either store them as references or
1.704 +// pointers). Such a type could be formed if make_tuple was called with a
1.705 +// reference to a function.
1.706 +// But this would mean that a const qualified function type was formed in
1.707 +// the make_tuple function and hence make_tuple can't take a function
1.708 +// reference as a parameter, and thus T can't be a function type.
1.709 +// So is_function test was removed.
1.710 +// (14.8.3. says that type deduction fails if a cv-qualified function type
1.711 +// is created. (It only applies for the case of explicitly specifying template
1.712 +// args, though?)) (JJ)
1.713 +
1.714 +template<class T>
1.715 +struct make_tuple_traits<T&> {
1.716 + typedef typename
1.717 + detail::generate_error<T&>::
1.718 + do_not_use_with_reference_type error;
1.719 +};
1.720 +
1.721 +// Arrays can't be stored as plain types; convert them to references.
1.722 +// All arrays are converted to const. This is because make_tuple takes its
1.723 +// parameters as const T& and thus the knowledge of the potential
1.724 +// non-constness of actual argument is lost.
1.725 +template<class T, int n> struct make_tuple_traits <T[n]> {
1.726 + typedef const T (&type)[n];
1.727 +};
1.728 +
1.729 +template<class T, int n>
1.730 +struct make_tuple_traits<const T[n]> {
1.731 + typedef const T (&type)[n];
1.732 +};
1.733 +
1.734 +template<class T, int n> struct make_tuple_traits<volatile T[n]> {
1.735 + typedef const volatile T (&type)[n];
1.736 +};
1.737 +
1.738 +template<class T, int n>
1.739 +struct make_tuple_traits<const volatile T[n]> {
1.740 + typedef const volatile T (&type)[n];
1.741 +};
1.742 +
1.743 +template<class T>
1.744 +struct make_tuple_traits<reference_wrapper<T> >{
1.745 + typedef T& type;
1.746 +};
1.747 +
1.748 +template<class T>
1.749 +struct make_tuple_traits<const reference_wrapper<T> >{
1.750 + typedef T& type;
1.751 +};
1.752 +
1.753 +
1.754 +
1.755 +
1.756 +namespace detail {
1.757 +
1.758 +// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's
1.759 +// suggestion)
1.760 +template <
1.761 + class T0 = null_type, class T1 = null_type, class T2 = null_type,
1.762 + class T3 = null_type, class T4 = null_type, class T5 = null_type,
1.763 + class T6 = null_type, class T7 = null_type, class T8 = null_type,
1.764 + class T9 = null_type
1.765 +>
1.766 +struct make_tuple_mapper {
1.767 + typedef
1.768 + tuple<typename make_tuple_traits<T0>::type,
1.769 + typename make_tuple_traits<T1>::type,
1.770 + typename make_tuple_traits<T2>::type,
1.771 + typename make_tuple_traits<T3>::type,
1.772 + typename make_tuple_traits<T4>::type,
1.773 + typename make_tuple_traits<T5>::type,
1.774 + typename make_tuple_traits<T6>::type,
1.775 + typename make_tuple_traits<T7>::type,
1.776 + typename make_tuple_traits<T8>::type,
1.777 + typename make_tuple_traits<T9>::type> type;
1.778 +};
1.779 +
1.780 +} // end detail
1.781 +
1.782 +// -make_tuple function templates -----------------------------------
1.783 +inline tuple<> make_tuple() {
1.784 + return tuple<>();
1.785 +}
1.786 +
1.787 +template<class T0>
1.788 +inline typename detail::make_tuple_mapper<T0>::type
1.789 +make_tuple(const T0& t0) {
1.790 + typedef typename detail::make_tuple_mapper<T0>::type t;
1.791 + return t(t0);
1.792 +}
1.793 +
1.794 +template<class T0, class T1>
1.795 +inline typename detail::make_tuple_mapper<T0, T1>::type
1.796 +make_tuple(const T0& t0, const T1& t1) {
1.797 + typedef typename detail::make_tuple_mapper<T0, T1>::type t;
1.798 + return t(t0, t1);
1.799 +}
1.800 +
1.801 +template<class T0, class T1, class T2>
1.802 +inline typename detail::make_tuple_mapper<T0, T1, T2>::type
1.803 +make_tuple(const T0& t0, const T1& t1, const T2& t2) {
1.804 + typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t;
1.805 + return t(t0, t1, t2);
1.806 +}
1.807 +
1.808 +template<class T0, class T1, class T2, class T3>
1.809 +inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type
1.810 +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
1.811 + typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t;
1.812 + return t(t0, t1, t2, t3);
1.813 +}
1.814 +
1.815 +template<class T0, class T1, class T2, class T3, class T4>
1.816 +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type
1.817 +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
1.818 + const T4& t4) {
1.819 + typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t;
1.820 + return t(t0, t1, t2, t3, t4);
1.821 +}
1.822 +
1.823 +template<class T0, class T1, class T2, class T3, class T4, class T5>
1.824 +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type
1.825 +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
1.826 + const T4& t4, const T5& t5) {
1.827 + typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t;
1.828 + return t(t0, t1, t2, t3, t4, t5);
1.829 +}
1.830 +
1.831 +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6>
1.832 +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type
1.833 +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
1.834 + const T4& t4, const T5& t5, const T6& t6) {
1.835 + typedef typename detail::make_tuple_mapper
1.836 + <T0, T1, T2, T3, T4, T5, T6>::type t;
1.837 + return t(t0, t1, t2, t3, t4, t5, t6);
1.838 +}
1.839 +
1.840 +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
1.841 + class T7>
1.842 +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type
1.843 +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
1.844 + const T4& t4, const T5& t5, const T6& t6, const T7& t7) {
1.845 + typedef typename detail::make_tuple_mapper
1.846 + <T0, T1, T2, T3, T4, T5, T6, T7>::type t;
1.847 + return t(t0, t1, t2, t3, t4, t5, t6, t7);
1.848 +}
1.849 +
1.850 +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
1.851 + class T7, class T8>
1.852 +inline typename detail::make_tuple_mapper
1.853 + <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type
1.854 +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
1.855 + const T4& t4, const T5& t5, const T6& t6, const T7& t7,
1.856 + const T8& t8) {
1.857 + typedef typename detail::make_tuple_mapper
1.858 + <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t;
1.859 + return t(t0, t1, t2, t3, t4, t5, t6, t7, t8);
1.860 +}
1.861 +
1.862 +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6,
1.863 + class T7, class T8, class T9>
1.864 +inline typename detail::make_tuple_mapper
1.865 + <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type
1.866 +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3,
1.867 + const T4& t4, const T5& t5, const T6& t6, const T7& t7,
1.868 + const T8& t8, const T9& t9) {
1.869 + typedef typename detail::make_tuple_mapper
1.870 + <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t;
1.871 + return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9);
1.872 +}
1.873 +
1.874 +
1.875 +
1.876 +// Tie function templates -------------------------------------------------
1.877 +template<class T1>
1.878 +inline tuple<T1&> tie(T1& t1) {
1.879 + return tuple<T1&> (t1);
1.880 +}
1.881 +
1.882 +template<class T1, class T2>
1.883 +inline tuple<T1&, T2&> tie(T1& t1, T2& t2) {
1.884 + return tuple<T1&, T2&> (t1, t2);
1.885 +}
1.886 +
1.887 +template<class T1, class T2, class T3>
1.888 +inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) {
1.889 + return tuple<T1&, T2&, T3&> (t1, t2, t3);
1.890 +}
1.891 +
1.892 +template<class T1, class T2, class T3, class T4>
1.893 +inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) {
1.894 + return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
1.895 +}
1.896 +
1.897 +template<class T1, class T2, class T3, class T4, class T5>
1.898 +inline tuple<T1&, T2&, T3&, T4&, T5&>
1.899 +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
1.900 + return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5);
1.901 +}
1.902 +
1.903 +template<class T1, class T2, class T3, class T4, class T5, class T6>
1.904 +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&>
1.905 +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) {
1.906 + return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6);
1.907 +}
1.908 +
1.909 +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
1.910 +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&>
1.911 +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) {
1.912 + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7);
1.913 +}
1.914 +
1.915 +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
1.916 + class T8>
1.917 +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
1.918 +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
1.919 + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
1.920 + (t1, t2, t3, t4, t5, t6, t7, t8);
1.921 +}
1.922 +
1.923 +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
1.924 + class T8, class T9>
1.925 +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
1.926 +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
1.927 + T9& t9) {
1.928 + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
1.929 + (t1, t2, t3, t4, t5, t6, t7, t8, t9);
1.930 +}
1.931 +
1.932 +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
1.933 + class T8, class T9, class T10>
1.934 +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
1.935 +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8,
1.936 + T9& t9, T10& t10) {
1.937 + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&>
1.938 + (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
1.939 +}
1.940 +
1.941 +} // end of namespace tuples
1.942 +} // end of namespace boost
1.943 +
1.944 +
1.945 +#endif // BOOST_TUPLE_BASIC_HPP
1.946 +
1.947 +