summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/src/boost/tuple')
-rw-r--r--3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp19
-rw-r--r--3rdParty/Boost/src/boost/tuple/detail/tuple_basic_no_partial_spec.hpp865
-rw-r--r--3rdParty/Boost/src/boost/tuple/tuple.hpp25
3 files changed, 15 insertions, 894 deletions
diff --git a/3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp b/3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp
index 88f0d90..5f26c7f 100644
--- a/3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp
+++ b/3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp
@@ -41,6 +41,11 @@
#include "boost/detail/workaround.hpp" // needed for BOOST_WORKAROUND
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
+#endif
+
namespace boost {
namespace tuples {
@@ -208,7 +213,7 @@ template<int N, class HT, class TT>
inline typename access_traits<
typename element<N, cons<HT, TT> >::type
>::non_const_type
-get(cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(cons<HT, TT>& c) {
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
apply<cons<HT, TT> > impl;
typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
@@ -222,10 +227,9 @@ template<int N, class HT, class TT>
inline typename access_traits<
typename element<N, cons<HT, TT> >::type
>::const_type
-get(const cons<HT, TT>& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+get(const cons<HT, TT>& c) {
typedef BOOST_DEDUCED_TYPENAME detail::drop_front<N>::BOOST_NESTED_TEMPLATE
apply<cons<HT, TT> > impl;
- typedef BOOST_DEDUCED_TYPENAME impl::type cons_element;
return impl::call(c).head;
}
@@ -399,7 +403,7 @@ struct cons<HT, null_type> {
typename access_traits<
typename element<N, self_type>::type
>::non_const_type
- get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) {
+ get() {
return boost::tuples::get<N>(*this);
}
@@ -407,7 +411,7 @@ struct cons<HT, null_type> {
typename access_traits<
typename element<N, self_type>::type
>::const_type
- get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const {
+ get() const {
return boost::tuples::get<N>(*this);
}
@@ -975,6 +979,11 @@ inline void swap(tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>& lhs,
} // end of namespace boost
+#if BOOST_GCC >= 40700
+#pragma GCC diagnostic pop
+#endif
+
+
#endif // BOOST_TUPLE_BASIC_HPP
diff --git a/3rdParty/Boost/src/boost/tuple/detail/tuple_basic_no_partial_spec.hpp b/3rdParty/Boost/src/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
deleted file mode 100644
index 7379bf8..0000000
--- a/3rdParty/Boost/src/boost/tuple/detail/tuple_basic_no_partial_spec.hpp
+++ /dev/null
@@ -1,865 +0,0 @@
-// - 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
diff --git a/3rdParty/Boost/src/boost/tuple/tuple.hpp b/3rdParty/Boost/src/boost/tuple/tuple.hpp
index 7703597..433d4b3 100644
--- a/3rdParty/Boost/src/boost/tuple/tuple.hpp
+++ b/3rdParty/Boost/src/boost/tuple/tuple.hpp
@@ -23,16 +23,10 @@ namespace boost { namespace python { class tuple; }}
#include "boost/config.hpp"
#include "boost/static_assert.hpp"
-#if defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
-// The MSVC version
-#include "boost/tuple/detail/tuple_basic_no_partial_spec.hpp"
-
-#else
// other compilers
#include "boost/ref.hpp"
#include "boost/tuple/detail/tuple_basic.hpp"
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
namespace boost {
@@ -41,7 +35,7 @@ using tuples::make_tuple;
using tuples::tie;
#if !defined(BOOST_NO_USING_TEMPLATE)
using tuples::get;
-#elif !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#else
//
// The "using tuples::get" statement causes the
// Borland compiler to ICE, use forwarding
@@ -64,24 +58,7 @@ inline typename tuples::access_traits<
get(const tuples::cons<HT, TT>& c) {
return tuples::get<N,HT,TT>(c);
}
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//
-// MSVC, using declarations don't mix with templates well,
-// so use forwarding functions instead:
-//
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_ref<N, tuples::cons<Head, Tail> >::RET
-get(tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
- return tuples::detail::get_class<N>::get(t);
-}
-template<int N, typename Head, typename Tail>
-typename tuples::detail::element_const_ref<N, tuples::cons<Head, Tail> >::RET
-get(const tuples::cons<Head, Tail>& t, tuples::detail::workaround_holder<N>* = 0)
-{
- return tuples::detail::get_class<N>::get(t);
-}
#endif // BOOST_NO_USING_TEMPLATE
} // end namespace boost