forked from boostorg/tuple
This commit was manufactured by cvs2svn to create branch 'rich_cons'.
[SVN r10928]
This commit is contained in:
nobody committed
1 parent
d84c84e7ed
commit
0b8d721265
13 files changed
-2802
No files matched your search
@@ -1,654 +0,0 @@
|
||||
// - tuple_basic_no_partial_spec.hpp -----------------------------------------
|
||||
|
||||
// Copyright (C) 1999, 2000 Jaakko Järvi (jaakko.jarvi@cs.utu.fi)
|
||||
// Copyright (C) 2001 Doug Gregor (gregod@rpi.edu)
|
||||
// Copyright (C) 2001 Gary Powell (gary.powell@sierra.com)
|
||||
//
|
||||
// Permission to copy, use, sell and distribute this software is granted
|
||||
// provided this copyright notice appears in all copies.
|
||||
// Permission to modify the code and to distribute modified code is granted
|
||||
// provided this copyright notice appears in all copies, and a notice
|
||||
// that the code was modified is included with the copyright notice.
|
||||
//
|
||||
// This software is provided "as is" without express or implied warranty,
|
||||
// and with no claim as to its suitability for any purpose.
|
||||
|
||||
// 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"
|
||||
|
||||
#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 {
|
||||
|
||||
// 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(); }
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
// 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& operator=(const T&)
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
} // end of namespace tuples
|
||||
} // end of namespace detail
|
||||
|
||||
// cons builds a heterogenous list of types
|
||||
template<typename Head, typename Tail = null_type>
|
||||
struct cons
|
||||
{
|
||||
typedef cons self_type;
|
||||
typedef Head head_type;
|
||||
typedef Tail tail_type;
|
||||
|
||||
head_type head;
|
||||
tail_type tail;
|
||||
|
||||
typename boost::add_reference<head_type>::type get_head() { return head; }
|
||||
typename boost::add_reference<tail_type>::type get_tail() { return tail; }
|
||||
|
||||
typename boost::add_reference<const head_type>::type get_head() const { return head; }
|
||||
typename boost::add_reference<const tail_type>::type get_tail() const { return tail; }
|
||||
|
||||
template<typename Other>
|
||||
explicit cons(const Other& other) : head(other.head), tail(other.tail)
|
||||
{
|
||||
}
|
||||
|
||||
#if defined BOOST_MSVC
|
||||
explicit cons(const head_type& h /* = head_type() */, // causes MSVC 6.5 to barf.
|
||||
const tail_type& t = tail_type()) :
|
||||
head(h), tail(t)
|
||||
{
|
||||
}
|
||||
#else
|
||||
explicit cons(const head_type& h = head_type(),
|
||||
const tail_type& t = tail_type()) :
|
||||
head(h), tail(t)
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
template<typename Other>
|
||||
cons& operator=(const Other& other)
|
||||
{
|
||||
head = other.head;
|
||||
tail = other.tail;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
// 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::tuples::build_cons<T10, null_type >::RET cons10;
|
||||
typedef typename detail::tuples::build_cons<T9, cons10>::RET cons9;
|
||||
typedef typename detail::tuples::build_cons<T8, cons9>::RET cons8;
|
||||
typedef typename detail::tuples::build_cons<T7, cons8>::RET cons7;
|
||||
typedef typename detail::tuples::build_cons<T6, cons7>::RET cons6;
|
||||
typedef typename detail::tuples::build_cons<T5, cons6>::RET cons5;
|
||||
typedef typename detail::tuples::build_cons<T4, cons5>::RET cons4;
|
||||
typedef typename detail::tuples::build_cons<T3, cons4>::RET cons3;
|
||||
typedef typename detail::tuples::build_cons<T2, cons3>::RET cons2;
|
||||
typedef typename detail::tuples::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;
|
||||
};
|
||||
};
|
||||
} // detail
|
||||
} // tuples
|
||||
|
||||
// Return the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct tuple_element
|
||||
{
|
||||
private:
|
||||
typedef detail::tuples::_element_type<N> nth_type;
|
||||
|
||||
public:
|
||||
typedef typename nth_type::template inner<Tuple>::RET RET;
|
||||
typedef RET type;
|
||||
};
|
||||
|
||||
namespace detail {
|
||||
namespace tuples {
|
||||
// Return a reference to the Nth type of the given Tuple
|
||||
template<int N, typename Tuple>
|
||||
struct tuple_element_ref
|
||||
{
|
||||
private:
|
||||
typedef typename tuple_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 tuple_element_const_ref
|
||||
{
|
||||
private:
|
||||
typedef typename tuple_element<N, Tuple>::RET elt_type;
|
||||
|
||||
public:
|
||||
typedef typename add_reference<const elt_type>::type RET;
|
||||
typedef RET type;
|
||||
};
|
||||
}
|
||||
}
|
||||
// Get length of this tuple
|
||||
template<typename Tuple>
|
||||
struct tuple_length
|
||||
{
|
||||
enum { value = 1 + tuple_length<typename Tuple::tail_type>::value };
|
||||
};
|
||||
|
||||
template<>
|
||||
struct tuple_length<null_type>
|
||||
{
|
||||
enum { value = 0 };
|
||||
};
|
||||
|
||||
// Reference the Nth element in a tuple and retrieve it with "get"
|
||||
template<int N>
|
||||
struct element
|
||||
{
|
||||
template<typename Tuple>
|
||||
static inline
|
||||
typename detail::tuples::tuple_element_ref<N, Tuple>::RET
|
||||
get(Tuple& t)
|
||||
{
|
||||
return element<N-1>::get(t.tail);
|
||||
}
|
||||
|
||||
template<typename Tuple>
|
||||
static inline
|
||||
typename detail::tuples::tuple_element_const_ref<N, Tuple>::RET
|
||||
get(const Tuple& t)
|
||||
{
|
||||
return element<N-1>::get(t.tail);
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct element<0>
|
||||
{
|
||||
template<typename Tuple>
|
||||
static inline
|
||||
typename add_reference<typename Tuple::head_type>::type
|
||||
get(Tuple& t)
|
||||
{
|
||||
return t.head;
|
||||
}
|
||||
|
||||
template<typename Tuple>
|
||||
static inline
|
||||
typename add_reference<const typename Tuple::head_type>::type
|
||||
get(const Tuple& t)
|
||||
{
|
||||
return t.head;
|
||||
}
|
||||
};
|
||||
|
||||
// tuple class
|
||||
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
|
||||
>
|
||||
class tuple :
|
||||
public detail::tuples::map_tuple_to_cons<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::cons1
|
||||
{
|
||||
private:
|
||||
typedef detail::tuples::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;
|
||||
|
||||
public:
|
||||
typedef tuple self_type;
|
||||
|
||||
explicit tuple(const T1& t1 = T1(),
|
||||
const T2& t2 = T2(),
|
||||
const T3& t3 = T3(),
|
||||
const T4& t4 = T4(),
|
||||
const T5& t5 = T5(),
|
||||
const T6& t6 = T6(),
|
||||
const T7& t7 = T7(),
|
||||
const T8& t8 = T8(),
|
||||
const T9& t9 = T9(),
|
||||
const T10& t10 = T10()) :
|
||||
cons1(t1, cons2(t2, cons3(t3, cons4(t4, cons5(t5, cons6(t6,cons7(t7,cons8(t8,cons9(t9,cons10(t10))))))))))
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Other>
|
||||
explicit tuple(const Other& other) : cons1(other)
|
||||
{
|
||||
}
|
||||
|
||||
template<typename Other>
|
||||
self_type& operator=(const Other& other)
|
||||
{
|
||||
this->head = other.head;
|
||||
this->tail = other.tail;
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
// Retrieve the Nth element in the typle
|
||||
template<int N, typename Tuple>
|
||||
typename detail::tuples::tuple_element_ref<N, Tuple>::RET
|
||||
get(Tuple& t)
|
||||
{
|
||||
return element<N>::get(t);
|
||||
}
|
||||
|
||||
// Retrieve the Nth element in the typle
|
||||
template<int N, typename Tuple>
|
||||
typename detail::tuples::tuple_element_const_ref<N, Tuple>::RET
|
||||
get(const Tuple& t)
|
||||
{
|
||||
return element<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::tuples::assign_to_pointee<T1> >
|
||||
tie(T1& t1)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2> >
|
||||
tie(T1& t1, T2& t2)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3> >
|
||||
tie(T1& t1, T2& t2, T3& t3)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T6>(&t5),
|
||||
detail::tuples::assign_to_pointee<T5>(&t6));
|
||||
}
|
||||
|
||||
// Tie variables into a tuple
|
||||
template<typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
|
||||
inline
|
||||
tuple<detail::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7> >
|
||||
tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7)
|
||||
{
|
||||
return make_tuple(detail::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7>,
|
||||
detail::tuples::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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::assign_to_pointee<T7>(&t7),
|
||||
detail::tuples::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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7>,
|
||||
detail::tuples::assign_to_pointee<T8>,
|
||||
detail::tuples::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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::assign_to_pointee<T7>(&t7),
|
||||
detail::tuples::assign_to_pointee<T8>(&t8),
|
||||
detail::tuples::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::tuples::assign_to_pointee<T1>,
|
||||
detail::tuples::assign_to_pointee<T2>,
|
||||
detail::tuples::assign_to_pointee<T3>,
|
||||
detail::tuples::assign_to_pointee<T4>,
|
||||
detail::tuples::assign_to_pointee<T5>,
|
||||
detail::tuples::assign_to_pointee<T6>,
|
||||
detail::tuples::assign_to_pointee<T7>,
|
||||
detail::tuples::assign_to_pointee<T8>,
|
||||
detail::tuples::assign_to_pointee<T9>,
|
||||
detail::tuples::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::tuples::assign_to_pointee<T1>(&t1),
|
||||
detail::tuples::assign_to_pointee<T2>(&t2),
|
||||
detail::tuples::assign_to_pointee<T3>(&t3),
|
||||
detail::tuples::assign_to_pointee<T4>(&t4),
|
||||
detail::tuples::assign_to_pointee<T5>(&t5),
|
||||
detail::tuples::assign_to_pointee<T6>(&t6),
|
||||
detail::tuples::assign_to_pointee<T7>(&t7),
|
||||
detail::tuples::assign_to_pointee<T8>(&t8),
|
||||
detail::tuples::assign_to_pointee<T9>(&t9),
|
||||
detail::tuples::assign_to_pointee<T10>(&t10));
|
||||
}
|
||||
// "ignore" allows tuple positions to be ignored when using "tie".
|
||||
namespace {
|
||||
detail::tuples::swallow_assign ignore;
|
||||
}
|
||||
|
||||
} // namespace boost
|
||||
#endif // BOOST_TUPLE_BASIC_NO_PARTIAL_SPEC_HPP
|
||||
Reference in new issue
Block a user