866 lines
28 KiB
C++
866 lines
28 KiB
C++
// - tuple_basic_no_partial_spec.hpp -----------------------------------------
|
|
|
|
// Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
|
|
// Copyright (C) 2001 Douglas Gregor (gregod@rpi.edu)
|
|
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0. (See
|
|
// accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt)
|
|
|
|
// For more information, see http://www.boost.org or http://lambda.cs.utu.fi
|
|
|
|
// Revision History
|
|
// 14 02 01 Remove extra ';'. Also, fixed 10-parameter to make_tuple. (DG)
|
|
// 10 02 01 Fixed "null_type" constructors.
|
|
// Implemented comparison operators globally.
|
|
// Hide element_type_ref and element_type_const_ref.
|
|
// (DG).
|
|
// 09 02 01 Extended to tuples of length 10. Changed comparison for
|
|
// operator<()
|
|
// to the same used by std::pair<>, added cnull_type() (GP)
|
|
// 03 02 01 Initial Version from original tuple.hpp code by JJ. (DG)
|
|
|
|
// -----------------------------------------------------------------
|
|
|
|
#ifndef BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
|
#define BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
|
|
|
#include "boost/type_traits.hpp"
|
|
#include "boost/utility/swap.hpp"
|
|
#include <utility>
|
|
|
|
#if defined BOOST_MSVC
|
|
#pragma warning(disable:4518) // storage-class or type specifier(s) unexpected here; ignored
|
|
#pragma warning(disable:4181) // qualifier applied to reference type ignored
|
|
#pragma warning(disable:4227) // qualifier applied to reference type ignored
|
|
#endif
|
|
|
|
namespace boost {
|
|
namespace tuples {
|
|
|
|
// null_type denotes the end of a list built with "cons"
|
|
struct null_type
|
|
{
|
|
null_type() {}
|
|
null_type(const null_type&, const null_type&) {}
|
|
};
|
|
|
|
// a helper function to provide a const null_type type temporary
|
|
inline const null_type cnull_type() { return null_type(); }
|
|
|
|
// forward declaration of tuple
|
|
template<
|
|
typename T1 = null_type,
|
|
typename T2 = null_type,
|
|
typename T3 = null_type,
|
|
typename T4 = null_type,
|
|
typename T5 = null_type,
|
|
typename T6 = null_type,
|
|
typename T7 = null_type,
|
|
typename T8 = null_type,
|
|
typename T9 = null_type,
|
|
typename T10 = null_type
|
|
>
|
|
class tuple;
|
|
|
|
// forward declaration of cons
|
|
template<typename Head, typename Tail = null_type>
|
|
struct cons;
|
|
|
|
namespace detail {
|
|
|
|
// Takes a pointer and routes all assignments to whatever it points to
|
|
template<typename T>
|
|
struct assign_to_pointee
|
|
{
|
|
public:
|
|
explicit assign_to_pointee(T* p) : ptr(p) {}
|
|
|
|
template<typename Other>
|
|
assign_to_pointee& operator=(const Other& other)
|
|
{
|
|
*ptr = other;
|
|
return *this;
|
|
}
|
|
|
|
private:
|
|
T* ptr;
|
|
};
|
|
|
|
// Swallows any assignment
|
|
struct swallow_assign
|
|
{
|
|
template<typename T>
|
|
swallow_assign const& operator=(const T&) const
|
|
{
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
template <typename T> struct add_const_reference : add_reference<typename add_const<T>::type> {};
|
|
|
|
template <class MyTail>
|
|
struct init_tail
|
|
{
|
|
// Each of vc6 and vc7 seem to require a different formulation
|
|
// of this return type
|
|
template <class H, class T>
|
|
#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
|
|
static typename add_reference<typename add_const<T>::type>::type
|
|
#else
|
|
static typename add_const_reference<T>::type
|
|
#endif
|
|
execute( cons<H,T> const& u, long )
|
|
{
|
|
return u.get_tail();
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct init_tail<null_type>
|
|
{
|
|
template <class H>
|
|
static null_type execute( cons<H,null_type> const& u, long )
|
|
{
|
|
return null_type();
|
|
}
|
|
|
|
template <class U>
|
|
static null_type execute(U const&, ...)
|
|
{
|
|
return null_type();
|
|
}
|
|
private:
|
|
template <class H, class T>
|
|
void execute( cons<H,T> const&, int);
|
|
};
|
|
|
|
template <class Other>
|
|
Other const&
|
|
init_head( Other const& u, ... )
|
|
{
|
|
return u;
|
|
}
|
|
|
|
template <class H, class T>
|
|
typename add_reference<typename add_const<H>::type>::type
|
|
init_head( cons<H,T> const& u, int )
|
|
{
|
|
return u.get_head();
|
|
}
|
|
|
|
inline char**** init_head(null_type const&, int);
|
|
|
|
} // end of namespace detail
|
|
|
|
// cons builds a heterogenous list of types
|
|
template<typename Head, typename Tail>
|
|
struct cons
|
|
{
|
|
typedef cons self_type;
|
|
typedef Head head_type;
|
|
typedef Tail tail_type;
|
|
|
|
private:
|
|
typedef typename boost::add_reference<head_type>::type head_ref;
|
|
typedef typename boost::add_reference<tail_type>::type tail_ref;
|
|
typedef typename detail::add_const_reference<head_type>::type head_cref;
|
|
typedef typename detail::add_const_reference<tail_type>::type tail_cref;
|
|
public:
|
|
head_type head;
|
|
tail_type tail;
|
|
|
|
head_ref get_head() { return head; }
|
|
tail_ref get_tail() { return tail; }
|
|
|
|
head_cref get_head() const { return head; }
|
|
tail_cref get_tail() const { return tail; }
|
|
|
|
cons() : head(), tail() {}
|
|
|
|
#if defined BOOST_MSVC
|
|
template<typename Tail>
|
|
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
|
|
const Tail& t) : head(h), tail(t.head, t.tail)
|
|
{
|
|
}
|
|
|
|
cons(head_cref h /* = head_type() */, // causes MSVC 6.5 to barf.
|
|
const null_type& t) : head(h), tail(t)
|
|
{
|
|
}
|
|
|
|
#else
|
|
template<typename T>
|
|
explicit cons(head_cref h, const T& t) :
|
|
head(h), tail(t.head, t.tail)
|
|
{
|
|
}
|
|
|
|
explicit cons(head_cref h = head_type(),
|
|
tail_cref t = tail_type()) :
|
|
head(h), tail(t)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
template <class U>
|
|
cons( const U& u )
|
|
: head(detail::init_head(u, 0))
|
|
, tail(detail::init_tail<Tail>::execute(u, 0L))
|
|
{
|
|
}
|
|
|
|
template<typename Other>
|
|
cons& operator=(const Other& other)
|
|
{
|
|
head = other.head;
|
|
tail = other.tail;
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
namespace detail {
|
|
|
|
// Determines if the parameter is null_type
|
|
template<typename T> struct is_null_type { enum { RET = 0 }; };
|
|
template<> struct is_null_type<null_type> { enum { RET = 1 }; };
|
|
|
|
/* Build a cons structure from the given Head and Tail. If both are null_type,
|
|
return null_type. */
|
|
template<typename Head, typename Tail>
|
|
struct build_cons
|
|
{
|
|
private:
|
|
enum { tail_is_null_type = is_null_type<Tail>::RET };
|
|
public:
|
|
typedef cons<Head, Tail> RET;
|
|
};
|
|
|
|
template<>
|
|
struct build_cons<null_type, null_type>
|
|
{
|
|
typedef null_type RET;
|
|
};
|
|
|
|
// Map the N elements of a tuple into a cons list
|
|
template<
|
|
typename T1,
|
|
typename T2 = null_type,
|
|
typename T3 = null_type,
|
|
typename T4 = null_type,
|
|
typename T5 = null_type,
|
|
typename T6 = null_type,
|
|
typename T7 = null_type,
|
|
typename T8 = null_type,
|
|
typename T9 = null_type,
|
|
typename T10 = null_type
|
|
>
|
|
struct map_tuple_to_cons
|
|
{
|
|
typedef typename detail::build_cons<T10, null_type >::RET cons10;
|
|
typedef typename detail::build_cons<T9, cons10>::RET cons9;
|
|
typedef typename detail::build_cons<T8, cons9>::RET cons8;
|
|
typedef typename detail::build_cons<T7, cons8>::RET cons7;
|
|
typedef typename detail::build_cons<T6, cons7>::RET cons6;
|
|
typedef typename detail::build_cons<T5, cons6>::RET cons5;
|
|
typedef typename detail::build_cons<T4, cons5>::RET cons4;
|
|
typedef typename detail::build_cons<T3, cons4>::RET cons3;
|
|
typedef typename detail::build_cons<T2, cons3>::RET cons2;
|
|
typedef typename detail::build_cons<T1, cons2>::RET cons1;
|
|
};
|
|
|
|
// Workaround the lack of partial specialization in some compilers
|
|
template<int N>
|
|
struct _element_type
|
|
{
|
|
template<typename Tuple>
|
|
struct inner
|
|
{
|
|
private:
|
|
typedef typename Tuple::tail_type tail_type;
|
|
typedef _element_type<N-1> next_elt_type;
|
|
|
|
public:
|
|
typedef typename _element_type<N-1>::template inner<tail_type>::RET RET;
|
|
};
|
|
};
|
|
|
|
template<>
|
|
struct _element_type<0>
|
|
{
|
|
template<typename Tuple>
|
|
struct inner
|
|
{
|
|
typedef typename Tuple::head_type RET;
|
|
};
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
|
|
// Return the Nth type of the given Tuple
|
|
template<int N, typename Tuple>
|
|
struct element
|
|
{
|
|
private:
|
|
typedef detail::_element_type<N> nth_type;
|
|
|
|
public:
|
|
typedef typename nth_type::template inner<Tuple>::RET RET;
|
|
typedef RET type;
|
|
};
|
|
|
|
namespace detail {
|
|
|
|
#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300)
|
|
// special workaround for vc7:
|
|
|
|
template <bool x>
|
|
struct reference_adder
|
|
{
|
|
template <class T>
|
|
struct rebind
|
|
{
|
|
typedef T& type;
|
|
};
|
|
};
|
|
|
|
template <>
|
|
struct reference_adder<true>
|
|
{
|
|
template <class T>
|
|
struct rebind
|
|
{
|
|
typedef T type;
|
|
};
|
|
};
|
|
|
|
|
|
// Return a reference to the Nth type of the given Tuple
|
|
template<int N, typename Tuple>
|
|
struct element_ref
|
|
{
|
|
private:
|
|
typedef typename element<N, Tuple>::RET elt_type;
|
|
enum { is_ref = is_reference<elt_type>::value };
|
|
|
|
public:
|
|
typedef reference_adder<is_ref>::rebind<elt_type>::type RET;
|
|
typedef RET type;
|
|
};
|
|
|
|
// Return a const reference to the Nth type of the given Tuple
|
|
template<int N, typename Tuple>
|
|
struct element_const_ref
|
|
{
|
|
private:
|
|
typedef typename element<N, Tuple>::RET elt_type;
|
|
enum { is_ref = is_reference<elt_type>::value };
|
|
|
|
public:
|
|
typedef reference_adder<is_ref>::rebind<const elt_type>::type RET;
|
|
typedef RET type;
|
|
};
|
|
|
|
#else // vc7
|
|
|
|
// Return a reference to the Nth type of the given Tuple
|
|
template<int N, typename Tuple>
|
|
struct element_ref
|
|
{
|
|
private:
|
|
typedef typename element<N, Tuple>::RET elt_type;
|
|
|
|
public:
|
|
typedef typename add_reference<elt_type>::type RET;
|
|
typedef RET type;
|
|
};
|
|
|
|
// Return a const reference to the Nth type of the given Tuple
|
|
template<int N, typename Tuple>
|
|
struct element_const_ref
|
|
{
|
|
private:
|
|
typedef typename element<N, Tuple>::RET elt_type;
|
|
|
|
public:
|
|
typedef typename add_reference<const elt_type>::type RET;
|
|
typedef RET type;
|
|
};
|
|
#endif // vc7
|
|
|
|
} // namespace detail
|
|
|
|
// Get length of this tuple
|
|
template<typename Tuple>
|
|
struct length
|
|
{
|
|
BOOST_STATIC_CONSTANT(int, value = 1 + length<typename Tuple::tail_type>::value);
|
|
};
|
|
|
|
template<> struct length<tuple<> > {
|
|
BOOST_STATIC_CONSTANT(int, value = 0);
|
|
};
|
|
|
|
template<>
|
|
struct length<null_type>
|
|
{
|
|
BOOST_STATIC_CONSTANT(int, value = 0);
|
|
};
|
|
|
|
namespace detail {
|
|
|
|
// Reference the Nth element in a tuple and retrieve it with "get"
|
|
template<int N>
|
|
struct get_class
|
|
{
|
|
template<typename Head, typename Tail>
|
|
static inline
|
|
typename detail::element_ref<N, cons<Head, Tail> >::RET
|
|
get(cons<Head, Tail>& t)
|
|
{
|
|
return get_class<N-1>::get(t.tail);
|
|
}
|
|
|
|
template<typename Head, typename Tail>
|
|
static inline
|
|
typename detail::element_const_ref<N, cons<Head, Tail> >::RET
|
|
get(const cons<Head, Tail>& t)
|
|
{
|
|
return get_class<N-1>::get(t.tail);
|
|
}
|
|
};
|
|
|
|
template<>
|
|
struct get_class<0>
|
|
{
|
|
template<typename Head, typename Tail>
|
|
static inline
|
|
typename add_reference<Head>::type
|
|
get(cons<Head, Tail>& t)
|
|
{
|
|
return t.head;
|
|
}
|
|
|
|
template<typename Head, typename Tail>
|
|
static inline
|
|
typename add_reference<const Head>::type
|
|
get(const cons<Head, Tail>& t)
|
|
{
|
|
return t.head;
|
|
}
|
|
};
|
|
|
|
} // namespace detail
|
|
|
|
// tuple class
|
|
template<
|
|
typename T1,
|
|
typename T2,
|
|
typename T3,
|
|
typename T4,
|
|
typename T5,
|
|
typename T6,
|
|
typename T7,
|
|
typename T8,
|
|
typename T9,
|
|
typename T10
|
|
>
|
|
class tuple :
|
|
public detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
|
|
{
|
|
private:
|
|
typedef detail::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> mapped_tuple;
|
|
typedef typename mapped_tuple::cons10 cons10;
|
|
typedef typename mapped_tuple::cons9 cons9;
|
|
typedef typename mapped_tuple::cons8 cons8;
|
|
typedef typename mapped_tuple::cons7 cons7;
|
|
typedef typename mapped_tuple::cons6 cons6;
|
|
typedef typename mapped_tuple::cons5 cons5;
|
|
typedef typename mapped_tuple::cons4 cons4;
|
|
typedef typename mapped_tuple::cons3 cons3;
|
|
typedef typename mapped_tuple::cons2 cons2;
|
|
typedef typename mapped_tuple::cons1 cons1;
|
|
|
|
typedef typename detail::add_const_reference<T1>::type t1_cref;
|
|
typedef typename detail::add_const_reference<T2>::type t2_cref;
|
|
typedef typename detail::add_const_reference<T3>::type t3_cref;
|
|
typedef typename detail::add_const_reference<T4>::type t4_cref;
|
|
typedef typename detail::add_const_reference<T5>::type t5_cref;
|
|
typedef typename detail::add_const_reference<T6>::type t6_cref;
|
|
typedef typename detail::add_const_reference<T7>::type t7_cref;
|
|
typedef typename detail::add_const_reference<T8>::type t8_cref;
|
|
typedef typename detail::add_const_reference<T9>::type t9_cref;
|
|
typedef typename detail::add_const_reference<T10>::type t10_cref;
|
|
public:
|
|
typedef cons1 inherited;
|
|
typedef tuple self_type;
|
|
|
|
tuple() : cons1(T1(), cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
|
|
{}
|
|
|
|
tuple(
|
|
t1_cref t1,
|
|
t2_cref t2,
|
|
t3_cref t3 = T3(),
|
|
t4_cref t4 = T4(),
|
|
t5_cref t5 = T5(),
|
|
t6_cref t6 = T6(),
|
|
t7_cref t7 = T7(),
|
|
t8_cref t8 = T8(),
|
|
t9_cref t9 = T9(),
|
|
t10_cref t10 = T10()
|
|
) :
|
|
cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
|
|
{
|
|
}
|
|
|
|
explicit tuple(t1_cref t1)
|
|
: cons1(t1, cons2(T2(), cons3(T3(), cons4(T4(), cons5(T5(), cons6(T6(),cons7(T7(),cons8(T8(),cons9(T9(),cons10(T10()))))))))))
|
|
{}
|
|
|
|
template<typename Head, typename Tail>
|
|
tuple(const cons<Head, Tail>& other) :
|
|
cons1(other.head, other.tail)
|
|
{
|
|
}
|
|
|
|
template<typename First, typename Second>
|
|
self_type& operator=(const std::pair<First, Second>& other)
|
|
{
|
|
this->head = other.first;
|
|
this->tail.head = other.second;
|
|
return *this;
|
|
}
|
|
|
|
template<typename Head, typename Tail>
|
|
self_type& operator=(const cons<Head, Tail>& other)
|
|
{
|
|
this->head = other.head;
|
|
this->tail = other.tail;
|
|
|
|
return *this;
|
|
}
|
|
};
|
|
|
|
namespace detail {
|
|
|
|
template<int N> struct workaround_holder {};
|
|
|
|
} // namespace detail
|
|
|
|
template<int N, typename Head, typename Tail>
|
|
typename detail::element_ref<N, cons<Head, Tail> >::RET
|
|
get(cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
|
|
{
|
|
return detail::get_class<N>::get(t);
|
|
}
|
|
|
|
template<int N, typename Head, typename Tail>
|
|
typename detail::element_const_ref<N, cons<Head, Tail> >::RET
|
|
get(const cons<Head, Tail>& t, detail::workaround_holder<N>* = 0)
|
|
{
|
|
return detail::get_class<N>::get(t);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1>
|
|
inline
|
|
tuple<T1>
|
|
make_tuple(const T1& t1)
|
|
{
|
|
return tuple<T1>(t1);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2>
|
|
inline
|
|
tuple<T1, T2>
|
|
make_tuple(const T1& t1, const T2& t2)
|
|
{
|
|
return tuple<T1, T2>(t1, t2);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3>
|
|
inline
|
|
tuple<T1, T2, T3>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3)
|
|
{
|
|
return tuple<T1, T2, T3>(t1, t2, t3);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4>
|
|
inline
|
|
tuple<T1, T2, T3, T4>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4)
|
|
{
|
|
return tuple<T1, T2, T3, T4>(t1, t2, t3, t4);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
|
inline
|
|
tuple<T1, T2, T3, T4, T5>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5)
|
|
{
|
|
return tuple<T1, T2, T3, T4, T5>(t1, t2, t3, t4, t5);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
|
|
inline
|
|
tuple<T1, T2, T3, T4, T5, T6>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6)
|
|
{
|
|
return tuple<T1, T2, T3, T4, T5, T6>(t1, t2, t3, t4, t5, t6);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
|
inline
|
|
tuple<T1, T2, T3, T4, T5, T6, T7>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7)
|
|
{
|
|
return tuple<T1, T2, T3, T4, T5, T6, T7>(t1, t2, t3, t4, t5, t6, t7);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
|
|
inline
|
|
tuple<T1, T2, T3, T4, T5, T6, T7, T8>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8)
|
|
{
|
|
return tuple<T1, T2, T3, T4, T5, T6, T7, T8>(t1, t2, t3, t4, t5, t6, t7, t8);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
|
|
inline
|
|
tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9)
|
|
{
|
|
return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>(t1, t2, t3, t4, t5, t6, t7, t8, t9);
|
|
}
|
|
|
|
// Make a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
|
|
inline
|
|
tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
|
|
make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6, const T7& t7, const T8& t8, const T9& t9, const T10& t10)
|
|
{
|
|
return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1> >
|
|
tie(T1& t1)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2> >
|
|
tie(T1& t1, T2& t2)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3> >
|
|
tie(T1& t1, T2& t2, T3& t3)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3>,
|
|
detail::assign_to_pointee<T4> >
|
|
tie(T1& t1, T2& t2, T3& t3, T4& t4)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3),
|
|
detail::assign_to_pointee<T4>(&t4));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3>,
|
|
detail::assign_to_pointee<T4>,
|
|
detail::assign_to_pointee<T5> >
|
|
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3),
|
|
detail::assign_to_pointee<T4>(&t4),
|
|
detail::assign_to_pointee<T5>(&t5));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3>,
|
|
detail::assign_to_pointee<T4>,
|
|
detail::assign_to_pointee<T5>,
|
|
detail::assign_to_pointee<T6> >
|
|
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3),
|
|
detail::assign_to_pointee<T4>(&t4),
|
|
detail::assign_to_pointee<T5>(&t5),
|
|
detail::assign_to_pointee<T6>(&t6));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3>,
|
|
detail::assign_to_pointee<T4>,
|
|
detail::assign_to_pointee<T5>,
|
|
detail::assign_to_pointee<T6>,
|
|
detail::assign_to_pointee<T7> >
|
|
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3),
|
|
detail::assign_to_pointee<T4>(&t4),
|
|
detail::assign_to_pointee<T5>(&t5),
|
|
detail::assign_to_pointee<T6>(&t6),
|
|
detail::assign_to_pointee<T7>(&t7));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3>,
|
|
detail::assign_to_pointee<T4>,
|
|
detail::assign_to_pointee<T5>,
|
|
detail::assign_to_pointee<T6>,
|
|
detail::assign_to_pointee<T7>,
|
|
detail::assign_to_pointee<T8> >
|
|
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3),
|
|
detail::assign_to_pointee<T4>(&t4),
|
|
detail::assign_to_pointee<T5>(&t5),
|
|
detail::assign_to_pointee<T6>(&t6),
|
|
detail::assign_to_pointee<T7>(&t7),
|
|
detail::assign_to_pointee<T8>(&t8));
|
|
}
|
|
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3>,
|
|
detail::assign_to_pointee<T4>,
|
|
detail::assign_to_pointee<T5>,
|
|
detail::assign_to_pointee<T6>,
|
|
detail::assign_to_pointee<T7>,
|
|
detail::assign_to_pointee<T8>,
|
|
detail::assign_to_pointee<T9> >
|
|
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3),
|
|
detail::assign_to_pointee<T4>(&t4),
|
|
detail::assign_to_pointee<T5>(&t5),
|
|
detail::assign_to_pointee<T6>(&t6),
|
|
detail::assign_to_pointee<T7>(&t7),
|
|
detail::assign_to_pointee<T8>(&t8),
|
|
detail::assign_to_pointee<T9>(&t9));
|
|
}
|
|
// Tie variables into a tuple
|
|
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
|
|
inline
|
|
tuple<detail::assign_to_pointee<T1>,
|
|
detail::assign_to_pointee<T2>,
|
|
detail::assign_to_pointee<T3>,
|
|
detail::assign_to_pointee<T4>,
|
|
detail::assign_to_pointee<T5>,
|
|
detail::assign_to_pointee<T6>,
|
|
detail::assign_to_pointee<T7>,
|
|
detail::assign_to_pointee<T8>,
|
|
detail::assign_to_pointee<T9>,
|
|
detail::assign_to_pointee<T10> >
|
|
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7, T8 &t8, T9 &t9, T10 &t10)
|
|
{
|
|
return make_tuple(detail::assign_to_pointee<T1>(&t1),
|
|
detail::assign_to_pointee<T2>(&t2),
|
|
detail::assign_to_pointee<T3>(&t3),
|
|
detail::assign_to_pointee<T4>(&t4),
|
|
detail::assign_to_pointee<T5>(&t5),
|
|
detail::assign_to_pointee<T6>(&t6),
|
|
detail::assign_to_pointee<T7>(&t7),
|
|
detail::assign_to_pointee<T8>(&t8),
|
|
detail::assign_to_pointee<T9>(&t9),
|
|
detail::assign_to_pointee<T10>(&t10));
|
|
}
|
|
// "ignore" allows tuple positions to be ignored when using "tie".
|
|
|
|
detail::swallow_assign const ignore = detail::swallow_assign();
|
|
|
|
template <class T0, class T1, class T2, class T3, class T4,
|
|
class T5, class T6, class T7, class T8, class T9>
|
|
void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
|
|
tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs);
|
|
inline void swap(null_type&, null_type&) {}
|
|
template<class HH>
|
|
inline void swap(cons<HH, null_type>& lhs, cons<HH, null_type>& rhs) {
|
|
::boost::swap(lhs.head, rhs.head);
|
|
}
|
|
template<class HH, class TT>
|
|
inline void swap(cons<HH, TT>& lhs, cons<HH, TT>& rhs) {
|
|
::boost::swap(lhs.head, rhs.head);
|
|
::boost::tuples::swap(lhs.tail, rhs.tail);
|
|
}
|
|
template <class T0, class T1, class T2, class T3, class T4,
|
|
class T5, class T6, class T7, class T8, class T9>
|
|
inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
|
|
tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& rhs) {
|
|
typedef tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> tuple_type;
|
|
typedef typename tuple_type::inherited base;
|
|
::boost::tuples::swap(static_cast<base&>(lhs), static_cast<base&>(rhs));
|
|
}
|
|
|
|
} // namespace tuples
|
|
} // namespace boost
|
|
#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|