Swiftdiff options
| author | Tobias Markmann <tm@ayena.de> | 2014-10-19 20:22:58 (GMT) |
|---|---|---|
| committer | Tobias Markmann <tm@ayena.de> | 2014-10-20 13:49:33 (GMT) |
| commit | 6b22dfcf59474dd016a0355a3102a1dd3692d92c (patch) | |
| tree | 2b1fd33be433a91e81fee84fdc2bf1b52575d934 /3rdParty/Boost/src/boost/tuple | |
| parent | 38b0cb785fea8eae5e48fae56440695fdfd10ee1 (diff) | |
| download | swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.zip swift-contrib-6b22dfcf59474dd016a0355a3102a1dd3692d92c.tar.bz2 | |
Update Boost in 3rdParty to version 1.56.0.
This updates Boost in our 3rdParty directory to version 1.56.0.
Updated our update.sh script to stop on error.
Changed error reporting in SwiftTools/CrashReporter.cpp to SWIFT_LOG due to
missing include of <iostream> with newer Boost.
Change-Id: I4b35c77de951333979a524097f35f5f83d325edc
Diffstat (limited to '3rdParty/Boost/src/boost/tuple')
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 @@ -9,70 +9,75 @@ // For more information, see http://www.boost.org // Outside help: // This and that, Gary Powell. // Fixed return types for get_head/get_tail // ( and other bugs ) per suggestion of Jens Maurer // simplified element type accessors + bug fix (Jeremy Siek) // Several changes/additions according to suggestions by Douglas Gregor, // William Kempf, Vesa Karvonen, John Max Skaller, Ed Brey, Beman Dawes, // David Abrahams. // Revision history: // 2002 05 01 Hugo Duncan: Fix for Borland after Jaakko's previous changes // 2002 04 18 Jaakko: tuple element types can be void or plain function // types, as long as no object is created. // Tuple objects can no hold even noncopyable types // such as arrays. // 2001 10 22 John Maddock // Fixes for Borland C++ // 2001 08 30 David Abrahams // Added default constructor for cons<>. // ----------------------------------------------------------------- #ifndef BOOST_TUPLE_BASIC_HPP #define BOOST_TUPLE_BASIC_HPP #include <utility> // needed for the assignment from pair to tuple #include "boost/type_traits/cv_traits.hpp" #include "boost/type_traits/function_traits.hpp" #include "boost/utility/swap.hpp" #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 { // -- null_type -------------------------------------------------------- struct null_type {}; // a helper function to provide a const null_type type temporary namespace detail { inline const null_type cnull() { return null_type(); } // -- if construct ------------------------------------------------ // Proposed by Krzysztof Czarnecki and Ulrich Eisenecker template <bool If, class Then, class Else> struct IF { typedef Then RET; }; template <class Then, class Else> struct IF<false, Then, Else> { typedef Else RET; }; } // end detail // - cons forward declaration ----------------------------------------------- template <class HT, class TT> struct cons; // - tuple forward declaration ----------------------------------------------- template < class T0 = null_type, class T1 = null_type, class T2 = null_type, class T3 = null_type, class T4 = null_type, class T5 = null_type, class T6 = null_type, class T7 = null_type, class T8 = null_type, class T9 = null_type> class tuple; // tuple_length forward declaration @@ -176,88 +181,87 @@ struct element: // Usage: get<N>(aTuple) // -- some traits classes for get functions // access traits lifted from detail namespace to be part of the interface, // (Joel de Guzman's suggestion). Rationale: get functions are part of the // interface, so should the way to express their return types be. template <class T> struct access_traits { typedef const T& const_type; typedef T& non_const_type; typedef const typename boost::remove_cv<T>::type& parameter_type; // used as the tuple constructors parameter types // Rationale: non-reference tuple element types can be cv-qualified. // It should be possible to initialize such types with temporaries, // and when binding temporaries to references, the reference must // be non-volatile and const. 8.5.3. (5) }; template <class T> struct access_traits<T&> { typedef T& const_type; typedef T& non_const_type; typedef T& parameter_type; }; // get function for non-const cons-lists, returns a reference to the element 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; return const_cast<cons_element&>(impl::call(c)).head; } // get function for const cons-lists, returns a const reference to // the element. If the element is a reference, returns the reference // as such (that is, can return a non-const reference) 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; } // -- the cons template -------------------------------------------------- namespace detail { // These helper templates wrap void types and plain function types. // The reationale is to allow one to write tuple types with those types // as elements, even though it is not possible to instantiate such object. // E.g: typedef tuple<void> some_type; // ok // but: some_type x; // fails template <class T> class non_storeable_type { non_storeable_type(); }; template <class T> struct wrap_non_storeable_type { typedef typename IF< ::boost::is_function<T>::value, non_storeable_type<T>, T >::RET type; }; template <> struct wrap_non_storeable_type<void> { typedef non_storeable_type<void> type; }; } // detail template <class HT, class TT> struct cons { typedef HT head_type; typedef TT tail_type; typedef typename detail::wrap_non_storeable_type<head_type>::type stored_head_type; @@ -367,79 +371,79 @@ struct cons<HT, null_type> { // cons() : head(detail::default_arg<HT>::f()) {} cons() : head() {} cons(typename access_traits<stored_head_type>::parameter_type h, const null_type& = null_type()) : head (h) {} template<class T1> cons(T1& t1, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&) : head (t1) {} cons(const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&, const null_type&) : head () {} template <class HT2> cons( const cons<HT2, null_type>& u ) : head(u.head) {} template <class HT2> cons& operator=(const cons<HT2, null_type>& u ) { head = u.head; return *this; } // must define assignment operator explicitely, implicit version // is illformed if HT is a reference cons& operator=(const cons& u) { head = u.head; return *this; } template <int N> 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); } template <int N> 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); } }; // templates for finding out the length of the tuple ------------------- template<class T> struct length { BOOST_STATIC_CONSTANT(int, value = 1 + length<typename T::tail_type>::value); }; template<> struct length<tuple<> > { BOOST_STATIC_CONSTANT(int, value = 0); }; template<> struct length<tuple<> const> { BOOST_STATIC_CONSTANT(int, value = 0); }; template<> struct length<null_type> { BOOST_STATIC_CONSTANT(int, value = 0); }; template<> struct length<null_type const> { BOOST_STATIC_CONSTANT(int, value = 0); }; namespace detail { // Tuple to cons mapper -------------------------------------------------- @@ -943,38 +947,43 @@ inline typename detail::tie_mapper tie(T0& t0, T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) { typedef typename detail::tie_mapper <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type t; return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); } 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)); } } // end of namespace tuples } // 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 @@ -1,90 +1,67 @@ // tuple.hpp - Boost Tuple Library -------------------------------------- // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi) // // 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 // ----------------------------------------------------------------- #ifndef BOOST_TUPLE_HPP #define BOOST_TUPLE_HPP #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 // Work around a compiler bug. // boost::python::tuple has to be seen by the compiler before the // boost::tuple class template. namespace boost { namespace python { class tuple; }} #endif #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 { using tuples::tuple; 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 // functions instead: // template<int N, class HT, class TT> inline typename tuples::access_traits< typename tuples::element<N, tuples::cons<HT, TT> >::type >::non_const_type get(tuples::cons<HT, TT>& c) { return tuples::get<N,HT,TT>(c); } // get function for const cons-lists, returns a const reference to // the element. If the element is a reference, returns the reference // as such (that is, can return a non-const reference) template<int N, class HT, class TT> inline typename tuples::access_traits< typename tuples::element<N, tuples::cons<HT, TT> >::type >::const_type 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 #endif // BOOST_TUPLE_HPP |