Swiftdiff options
| author | Remko Tronçon <git@el-tramo.be> | 2011-03-01 20:57:03 (GMT) |
|---|---|---|
| committer | Remko Tronçon <git@el-tramo.be> | 2011-03-01 21:25:56 (GMT) |
| commit | 182dc1c6cbed6ac2bbe297f856650367e0f12ba7 (patch) | |
| tree | f9f683e6688683eed559f37d2dfa2ed0966a89c1 | |
| parent | 48389cafdbf211d70fa56f453c6d3b652482a139 (diff) | |
| download | swift-182dc1c6cbed6ac2bbe297f856650367e0f12ba7.zip swift-182dc1c6cbed6ac2bbe297f856650367e0f12ba7.tar.bz2 | |
Introduce Lua::Value helper.
| -rw-r--r-- | 3rdParty/Boost/src/boost/assign/assignment_exception.hpp | 43 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/assign/list_of.hpp | 681 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp | 953 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/tuple/detail/tuple_basic_no_partial_spec.hpp | 841 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/tuple/tuple.hpp | 90 | ||||
| -rw-r--r-- | 3rdParty/Boost/src/boost/type_traits/cv_traits.hpp | 24 | ||||
| -rwxr-xr-x | 3rdParty/Boost/update.sh | 1 | ||||
| -rw-r--r-- | Sluift/Lua/Value.cpp | 66 | ||||
| -rw-r--r-- | Sluift/Lua/Value.h | 34 | ||||
| -rw-r--r-- | Sluift/SConscript | 1 | ||||
| -rw-r--r-- | Sluift/sluift.cpp | 75 | ||||
| -rw-r--r-- | Swiften/Elements/SoftwareVersion.h | 7 |
12 files changed, 2766 insertions, 50 deletions
diff --git a/3rdParty/Boost/src/boost/assign/assignment_exception.hpp b/3rdParty/Boost/src/boost/assign/assignment_exception.hpp new file mode 100644 index 0000000..5079c3a --- /dev/null +++ b/3rdParty/Boost/src/boost/assign/assignment_exception.hpp @@ -0,0 +1,43 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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/libs/assign/ +// + + +#ifndef BOOST_ASSIGN_ASSIGNMENT_EXCEPTION_HPP +#define BOOST_ASSIGN_ASSIGNMENT_EXCEPTION_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include <exception> + +namespace boost +{ + namespace assign + { + class assignment_exception : public std::exception + { + public: + assignment_exception( const char* _what ) + : what_( _what ) + { } + + virtual const char* what() const throw() + { + return what_; + } + + private: + const char* what_; + }; + } +} + +#endif diff --git a/3rdParty/Boost/src/boost/assign/list_of.hpp b/3rdParty/Boost/src/boost/assign/list_of.hpp new file mode 100644 index 0000000..6da444b --- /dev/null +++ b/3rdParty/Boost/src/boost/assign/list_of.hpp @@ -0,0 +1,681 @@ +// Boost.Assign library +// +// Copyright Thorsten Ottosen 2003-2004. Use, modification and +// distribution is subject to 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/libs/assign/ +// + + +#ifndef BOOST_ASSIGN_LIST_OF_HPP +#define BOOST_ASSIGN_LIST_OF_HPP + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +# pragma once +#endif + +#include <boost/assign/assignment_exception.hpp> +#include <boost/range/iterator_range.hpp> +#include <boost/config.hpp> +#include <boost/tuple/tuple.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_reference.hpp> +#include <boost/type_traits/is_reference.hpp> +#include <boost/static_assert.hpp> +#include <boost/type_traits/detail/yes_no_type.hpp> +#include <boost/type_traits/decay.hpp> +#include <boost/type_traits/is_array.hpp> +#include <boost/mpl/if.hpp> +#include <deque> +#include <cstddef> +#include <utility> + +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/iteration/local.hpp> + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +// BCB requires full type definition for is_array<> to work correctly. +#include <boost/array.hpp> +#endif + +namespace boost +{ + +// this here is necessary to avoid compiler error in <boost/array.hpp> +#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + template< class T, std::size_t sz > + class array; +#endif + +namespace assign_detail +{ + ///////////////////////////////////////////////////////////////////////// + // Part 0: common conversion code + ///////////////////////////////////////////////////////////////////////// + + template< class T > + struct assign_decay + { + // + // Add constness to array parameters + // to support string literals properly + // + typedef BOOST_DEDUCED_TYPENAME mpl::eval_if< + ::boost::is_array<T>, + ::boost::decay<const T>, + ::boost::decay<T> >::type type; + }; + + template< class T, std::size_t sz > + type_traits::yes_type assign_is_array( const array<T,sz>* ); + type_traits::no_type assign_is_array( ... ); + template< class T, class U > + type_traits::yes_type assign_is_pair( const std::pair<T,U>* ); + type_traits::no_type assign_is_pair( ... ); + + + + struct array_type_tag + { + #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + private: + char dummy_; // BCB would by default use 8 bytes + #endif + }; + struct adapter_type_tag + { + #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + private: + char dummy_; // BCB would by default use 8 bytes + #endif + }; + struct pair_type_tag + { + #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + private: + char dummy_; // BCB would by default use 8 bytes + #endif + }; + struct default_type_tag + { + #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + private: + char dummy_; // BCB would by default use 8 bytes + #endif + }; + + + + template< class DerivedTAssign, class Iterator > + class converter + { + public: // Range operations + typedef Iterator iterator; + typedef Iterator const_iterator; + + iterator begin() const + { + return static_cast<const DerivedTAssign*>(this)->begin(); + } + + iterator end() const + { + return static_cast<const DerivedTAssign*>(this)->end(); + } + + public: + + template< class Container > + Container convert_to_container() const + { + static Container* c = 0; + BOOST_STATIC_CONSTANT( bool, is_array_flag = sizeof( assign_detail::assign_is_array( c ) ) + == sizeof( type_traits::yes_type ) ); + + typedef BOOST_DEDUCED_TYPENAME mpl::if_c< is_array_flag, + array_type_tag, + default_type_tag >::type tag_type; + + return convert<Container>( c, tag_type() ); + } + + private: + + template< class Container > + Container convert( const Container*, default_type_tag ) const + { + +#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1) +// old Dinkumware doesn't support iterator type as template + Container result; + iterator it = begin(), + e = end(); + while( it != e ) + { + result.insert( result.end(), *it ); + ++it; + } + return result; +#else + return Container( begin(), end() ); +#endif + } + + template< class Array > + Array convert( const Array*, array_type_tag ) const + { + typedef BOOST_DEDUCED_TYPENAME Array::value_type value_type; + +#if BOOST_WORKAROUND(BOOST_INTEL, <= 910 ) || BOOST_WORKAROUND(__SUNPRO_CC, <= 0x580 ) + BOOST_DEDUCED_TYPENAME remove_const<Array>::type ar; +#else + Array ar; +#endif + const std::size_t sz = ar.size(); + if( sz < static_cast<const DerivedTAssign*>(this)->size() ) + throw assign::assignment_exception( "array initialized with too many elements" ); + std::size_t n = 0; + iterator i = begin(), + e = end(); + for( ; i != e; ++i, ++n ) + ar[n] = *i; + for( ; n < sz; ++n ) + ar[n] = value_type(); + return ar; + } + + template< class Adapter > + Adapter convert_to_adapter( const Adapter* = 0 ) const + { + Adapter a; + iterator i = begin(), + e = end(); + for( ; i != e; ++i ) + a.push( *i ); + return a; + } + + private: + struct adapter_converter; + friend struct adapter_converter; + + struct adapter_converter + { + const converter& gl; + adapter_converter( const converter& this_ ) : gl( this_ ) + {} + + adapter_converter( const adapter_converter& r ) + : gl( r.gl ) + { } + + template< class Adapter > + operator Adapter() const + { + return gl.convert_to_adapter<Adapter>(); + } + }; + + public: + template< class Container > + Container to_container( Container& c ) const + { + return convert( &c, default_type_tag() ); + } + + adapter_converter to_adapter() const + { + return adapter_converter( *this ); + } + + template< class Adapter > + Adapter to_adapter( Adapter& a ) const + { + return this->convert_to_adapter( &a ); + } + + template< class Array > + Array to_array( Array& a ) const + { + return convert( &a, array_type_tag() ); + } + }; + + template< class T, class I, class Range > + inline bool operator==( const converter<T,I>& l, const Range& r ) + { + return ::boost::iterator_range_detail::equal( l, r ); + } + + template< class T, class I, class Range > + inline bool operator==( const Range& l, const converter<T,I>& r ) + { + return r == l; + } + + template< class T, class I, class Range > + inline bool operator!=( const converter<T,I>& l, const Range& r ) + { + return !( l == r ); + } + + template< class T, class I, class Range > + inline bool operator!=( const Range& l, const converter<T,I>& r ) + { + return !( l == r ); + } + + template< class T, class I, class Range > + inline bool operator<( const converter<T,I>& l, const Range& r ) + { + return ::boost::iterator_range_detail::less_than( l, r ); + } + + template< class T, class I, class Range > + inline bool operator<( const Range& l, const converter<T,I>& r ) + { + return ::boost::iterator_range_detail::less_than( l, r ); + } + + template< class T, class I, class Range > + inline bool operator>( const converter<T,I>& l, const Range& r ) + { + return r < l; + } + + template< class T, class I, class Range > + inline bool operator>( const Range& l, const converter<T,I>& r ) + { + return r < l; + } + + template< class T, class I, class Range > + inline bool operator<=( const converter<T,I>& l, const Range& r ) + { + return !( l > r ); + } + + template< class T, class I, class Range > + inline bool operator<=( const Range& l, const converter<T,I>& r ) + { + return !( l > r ); + } + + template< class T, class I, class Range > + inline bool operator>=( const converter<T,I>& l, const Range& r ) + { + return !( l < r ); + } + + template< class T, class I, class Range > + inline bool operator>=( const Range& l, const converter<T,I>& r ) + { + return !( l < r ); + } + + template< class T, class I, class Elem, class Traits > + inline std::basic_ostream<Elem,Traits>& + operator<<( std::basic_ostream<Elem, Traits>& Os, + const converter<T,I>& r ) + { + return Os << ::boost::make_iterator_range( r.begin(), r.end() ); + } + + ///////////////////////////////////////////////////////////////////////// + // Part 1: flexible, but inefficient interface + ///////////////////////////////////////////////////////////////////////// + + template< class T > + class generic_list : + public converter< generic_list< BOOST_DEDUCED_TYPENAME assign_decay<T>::type >, + BOOST_DEDUCED_TYPENAME std::deque<BOOST_DEDUCED_TYPENAME + assign_decay<T>::type>::iterator > + { + typedef BOOST_DEDUCED_TYPENAME assign_decay<T>::type Ty; + typedef std::deque<Ty> impl_type; + mutable impl_type values_; + + public: + typedef BOOST_DEDUCED_TYPENAME impl_type::iterator iterator; + typedef iterator const_iterator; + typedef BOOST_DEDUCED_TYPENAME impl_type::value_type value_type; + typedef BOOST_DEDUCED_TYPENAME impl_type::size_type size_type; + typedef BOOST_DEDUCED_TYPENAME impl_type::difference_type difference_type; + + public: + iterator begin() const { return values_.begin(); } + iterator end() const { return values_.end(); } + bool empty() const { return values_.empty(); } + size_type size() const { return values_.size(); } + + private: + void push_back( value_type r ) { values_.push_back( r ); } + + public: + generic_list& operator,( const Ty& u ) + { + this->push_back( u ); + return *this; + } + + generic_list& operator()() + { + this->push_back( Ty() ); + return *this; + } + + generic_list& operator()( const Ty& u ) + { + this->push_back( u ); + return *this; + } + + +#ifndef BOOST_ASSIGN_MAX_PARAMS // use user's value +#define BOOST_ASSIGN_MAX_PARAMS 5 +#endif +#define BOOST_ASSIGN_MAX_PARAMETERS (BOOST_ASSIGN_MAX_PARAMS - 1) +#define BOOST_ASSIGN_PARAMS1(n) BOOST_PP_ENUM_PARAMS(n, class U) +#define BOOST_ASSIGN_PARAMS2(n) BOOST_PP_ENUM_BINARY_PARAMS(n, U, const& u) +#define BOOST_ASSIGN_PARAMS3(n) BOOST_PP_ENUM_PARAMS(n, u) +#define BOOST_ASSIGN_PARAMS4(n) BOOST_PP_ENUM_PARAMS(n, U) +#define BOOST_ASSIGN_PARAMS2_NO_REF(n) BOOST_PP_ENUM_BINARY_PARAMS(n, U, u) + +#define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS) +#define BOOST_PP_LOCAL_MACRO(n) \ + template< class U, BOOST_ASSIGN_PARAMS1(n) > \ + generic_list& operator()(U const& u, BOOST_ASSIGN_PARAMS2(n) ) \ + { \ + this->push_back( Ty(u, BOOST_ASSIGN_PARAMS3(n))); \ + return *this; \ + } \ + /**/ + +#include BOOST_PP_LOCAL_ITERATE() + + + template< class U > + generic_list& repeat( std::size_t sz, U u ) + { + std::size_t i = 0; + while( i++ != sz ) + this->push_back( u ); + return *this; + } + + template< class Nullary_function > + generic_list& repeat_fun( std::size_t sz, Nullary_function fun ) + { + std::size_t i = 0; + while( i++ != sz ) + this->push_back( fun() ); + return *this; + } + + template< class SinglePassIterator > + generic_list& range( SinglePassIterator first, + SinglePassIterator last ) + { + for( ; first != last; ++first ) + this->push_back( *first ); + return *this; + } + + template< class SinglePassRange > + generic_list& range( const SinglePassRange& r ) + { + return range( boost::begin(r), boost::end(r) ); + } + + template< class Container > + operator Container() const + { + return this-> BOOST_NESTED_TEMPLATE convert_to_container<Container>(); + } + }; + + ///////////////////////////////////////////////////////////////////////// + // Part 2: efficient, but inconvenient interface + ///////////////////////////////////////////////////////////////////////// + + template< class T > + struct assign_reference + { + assign_reference() + { /* intentionally empty */ } + + assign_reference( T& r ) : ref_(&r) + { } + + void operator=( T& r ) + { + ref_ = &r; + } + + operator T&() const + { + return *ref_; + } + + void swap( assign_reference& r ) + { + std::swap( *ref_, *r.ref_ ); + } + + T& get_ref() const + { + return *ref_; + } + + private: + T* ref_; + + }; + + template< class T > + inline bool operator<( const assign_reference<T>& l, + const assign_reference<T>& r ) + { + return l.get_ref() < r.get_ref(); + } + + template< class T > + inline bool operator>( const assign_reference<T>& l, + const assign_reference<T>& r ) + { + return l.get_ref() > r.get_ref(); + } + + template< class T > + inline void swap( assign_reference<T>& l, + assign_reference<T>& r ) + { + l.swap( r ); + } + + + + template< class T, int N > + struct static_generic_list : + public converter< static_generic_list<T,N>, assign_reference<T>* > + { + private: + typedef T internal_value_type; + + public: + typedef assign_reference<internal_value_type> value_type; + typedef value_type* iterator; + typedef value_type* const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + + static_generic_list( T& r ) : + current_(1) + { + refs_[0] = r; + } + + static_generic_list& operator()( T& r ) + { + insert( r ); + return *this; + } + + iterator begin() const + { + return &refs_[0]; + } + + iterator end() const + { + return &refs_[current_]; + } + + size_type size() const + { + return static_cast<size_type>( current_ ); + } + + bool empty() const + { + return false; + } + + template< class ForwardIterator > + static_generic_list& range( ForwardIterator first, + ForwardIterator last ) + { + for( ; first != last; ++first ) + this->insert( *first ); + return *this; + } + + template< class ForwardRange > + static_generic_list& range( ForwardRange& r ) + { + return range( boost::begin(r), boost::end(r) ); + } + + template< class ForwardRange > + static_generic_list& range( const ForwardRange& r ) + { + return range( boost::begin(r), boost::end(r) ); + } + + template< class Container > + operator Container() const + { + return this-> BOOST_NESTED_TEMPLATE convert_to_container<Container>(); + } + + private: + void insert( T& r ) + { + refs_[current_] = r; + ++current_; + } + + static_generic_list(); + + mutable assign_reference<internal_value_type> refs_[N]; + int current_; + }; + +} // namespace 'assign_detail' + +namespace assign +{ + template< class T > + inline assign_detail::generic_list<T> + list_of() + { + return assign_detail::generic_list<T>()( T() ); + } + + template< class T > + inline assign_detail::generic_list<T> + list_of( const T& t ) + { + return assign_detail::generic_list<T>()( t ); + } + + template< int N, class T > + inline assign_detail::static_generic_list< BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N> + ref_list_of( T& t ) + { + return assign_detail::static_generic_list<BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N>( t ); + } + + template< int N, class T > + inline assign_detail::static_generic_list<const BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N> + cref_list_of( const T& t ) + { + return assign_detail::static_generic_list<const BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type,N>( t ); + } + +#define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS) +#define BOOST_PP_LOCAL_MACRO(n) \ + template< class T, class U, BOOST_ASSIGN_PARAMS1(n) > \ + inline assign_detail::generic_list<T> \ + list_of(U const& u, BOOST_ASSIGN_PARAMS2(n) ) \ + { \ + return assign_detail::generic_list<T>()(u, BOOST_ASSIGN_PARAMS3(n)); \ + } \ + /**/ + +#include BOOST_PP_LOCAL_ITERATE() + +#define BOOST_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS) +#define BOOST_PP_LOCAL_MACRO(n) \ + template< class U, BOOST_ASSIGN_PARAMS1(n) > \ + inline assign_detail::generic_list< tuple<U, BOOST_ASSIGN_PARAMS4(n)> > \ + tuple_list_of(U u, BOOST_ASSIGN_PARAMS2_NO_REF(n) ) \ + { \ + return assign_detail::generic_list< tuple<U, BOOST_ASSIGN_PARAMS4(n)> >()( tuple<U,BOOST_ASSIGN_PARAMS4(n)>( u, BOOST_ASSIGN_PARAMS3(n) )); \ + } \ + /**/ + +#include BOOST_PP_LOCAL_ITERATE() + + + template< class Key, class T > + inline assign_detail::generic_list< std::pair + < + BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<Key>::type, + BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type + > > + map_list_of( const Key& k, const T& t ) + { + typedef BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<Key>::type k_type; + typedef BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<T>::type t_type; + return assign_detail::generic_list< std::pair<k_type,t_type> >()( k, t ); + } + + template< class F, class S > + inline assign_detail::generic_list< std::pair + < + BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<F>::type, + BOOST_DEDUCED_TYPENAME assign_detail::assign_decay<S>::type + > > + pair_list_of( const F& f, const S& s ) + { + return map_list_of( f, s ); + } + + +} // namespace 'assign' +} // namespace 'boost' + + +#undef BOOST_ASSIGN_PARAMS1 +#undef BOOST_ASSIGN_PARAMS2 +#undef BOOST_ASSIGN_PARAMS3 +#undef BOOST_ASSIGN_PARAMS4 +#undef BOOST_ASSIGN_PARAMS2_NO_REF +#undef BOOST_ASSIGN_MAX_PARAMETERS + +#endif diff --git a/3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp b/3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp new file mode 100644 index 0000000..348fd80 --- /dev/null +++ b/3rdParty/Boost/src/boost/tuple/detail/tuple_basic.hpp @@ -0,0 +1,953 @@ +// tuple_basic.hpp ----------------------------------------------------- + +// 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 + +// 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/detail/workaround.hpp" // needed for BOOST_WORKAROUND + +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 +template<class T> struct length; + + + +namespace detail { + +// -- generate error template, referencing to non-existing members of this +// template is used to produce compilation errors intentionally +template<class T> +class generate_error; + +// - cons getters -------------------------------------------------------- +// called: get_class<N>::get<RETURN_TYPE>(aTuple) + +template< int N > +struct get_class { + template<class RET, class HT, class TT > + inline static RET get(const cons<HT, TT>& t) + { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + // vacpp 6.0 is not very consistent regarding the member template keyword + // Here it generates an error when the template keyword is used. + return get_class<N-1>::get<RET>(t.tail); +#else + return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail); +#endif + } + template<class RET, class HT, class TT > + inline static RET get(cons<HT, TT>& t) + { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + return get_class<N-1>::get<RET>(t.tail); +#else + return get_class<N-1>::BOOST_NESTED_TEMPLATE get<RET>(t.tail); +#endif + } +}; + +template<> +struct get_class<0> { + template<class RET, class HT, class TT> + inline static RET get(const cons<HT, TT>& t) + { + return t.head; + } + template<class RET, class HT, class TT> + inline static RET get(cons<HT, TT>& t) + { + return t.head; + } +}; + +} // end of namespace detail + + +// -cons type accessors ---------------------------------------- +// typename tuples::element<N,T>::type gets the type of the +// Nth element ot T, first element is at index 0 +// ------------------------------------------------------- + +#ifndef BOOST_NO_CV_SPECIALIZATIONS + +template<int N, class T> +struct element +{ +private: + typedef typename T::tail_type Next; +public: + typedef typename element<N-1, Next>::type type; +}; +template<class T> +struct element<0,T> +{ + typedef typename T::head_type type; +}; + +template<int N, class T> +struct element<N, const T> +{ +private: + typedef typename T::tail_type Next; + typedef typename element<N-1, Next>::type unqualified_type; +public: +#if BOOST_WORKAROUND(__BORLANDC__,<0x600) + typedef const unqualified_type type; +#else + typedef typename boost::add_const<unqualified_type>::type type; +#endif + +}; +template<class T> +struct element<0,const T> +{ +#if BOOST_WORKAROUND(__BORLANDC__,<0x600) + typedef const typename T::head_type type; +#else + typedef typename boost::add_const<typename T::head_type>::type type; +#endif +}; + +#else // def BOOST_NO_CV_SPECIALIZATIONS + +namespace detail { + +template<int N, class T, bool IsConst> +struct element_impl +{ +private: + typedef typename T::tail_type Next; +public: + typedef typename element_impl<N-1, Next, IsConst>::type type; +}; + +template<int N, class T> +struct element_impl<N, T, true /* IsConst */> +{ +private: + typedef typename T::tail_type Next; +public: + typedef const typename element_impl<N-1, Next, true>::type type; +}; + +template<class T> +struct element_impl<0, T, false /* IsConst */> +{ + typedef typename T::head_type type; +}; + +template<class T> +struct element_impl<0, T, true /* IsConst */> +{ + typedef const typename T::head_type type; +}; + +} // end of namespace detail + + +template<int N, class T> +struct element: + public detail::element_impl<N, T, ::boost::is_const<T>::value> +{ +}; + +#endif + + +// -get function templates ----------------------------------------------- +// 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)) { +#if BOOST_WORKAROUND(__IBMCPP__,==600 ) + return detail::get_class<N>:: +#else + return detail::get_class<N>::BOOST_NESTED_TEMPLATE +#endif + get< + typename access_traits< + typename element<N, cons<HT, TT> >::type + >::non_const_type, + 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 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)) { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + return detail::get_class<N>:: +#else + return detail::get_class<N>::BOOST_NESTED_TEMPLATE +#endif + get< + typename access_traits< + typename element<N, cons<HT, TT> >::type + >::const_type, + HT,TT + >(c); +} + +// -- 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; + + stored_head_type head; + tail_type tail; + + typename access_traits<stored_head_type>::non_const_type + get_head() { return head; } + + typename access_traits<tail_type>::non_const_type + get_tail() { return tail; } + + typename access_traits<stored_head_type>::const_type + get_head() const { return head; } + + typename access_traits<tail_type>::const_type + get_tail() const { return tail; } + + cons() : head(), tail() {} + // cons() : head(detail::default_arg<HT>::f()), tail() {} + + // the argument for head is not strictly needed, but it prevents + // array type elements. This is good, since array type elements + // cannot be supported properly in any case (no assignment, + // copy works only if the tails are exactly the same type, ...) + + cons(typename access_traits<stored_head_type>::parameter_type h, + const tail_type& t) + : head (h), tail(t) {} + + template <class T1, class T2, class T3, class T4, class T5, + class T6, class T7, class T8, class T9, class T10> + cons( T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, + T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) + : head (t1), + tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull()) + {} + + template <class T2, class T3, class T4, class T5, + class T6, class T7, class T8, class T9, class T10> + cons( const null_type& /*t1*/, T2& t2, T3& t3, T4& t4, T5& t5, + T6& t6, T7& t7, T8& t8, T9& t9, T10& t10 ) + : head (), + tail (t2, t3, t4, t5, t6, t7, t8, t9, t10, detail::cnull()) + {} + + + template <class HT2, class TT2> + cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {} + + template <class HT2, class TT2> + cons& operator=( const cons<HT2, TT2>& u ) { + head=u.head; tail=u.tail; return *this; + } + + // must define assignment operator explicitly, implicit version is + // illformed if HT is a reference (12.8. (12)) + cons& operator=(const cons& u) { + head = u.head; tail = u.tail; return *this; + } + + template <class T1, class T2> + cons& operator=( const std::pair<T1, T2>& u ) { + BOOST_STATIC_ASSERT(length<cons>::value == 2); // check length = 2 + head = u.first; tail.head = u.second; return *this; + } + + // get member functions (non-const and const) + template <int N> + typename access_traits< + typename element<N, cons<HT, TT> >::type + >::non_const_type + get() { + return boost::tuples::get<N>(*this); // delegate to non-member get + } + + template <int N> + typename access_traits< + typename element<N, cons<HT, TT> >::type + >::const_type + get() const { + return boost::tuples::get<N>(*this); // delegate to non-member get + } +}; + +template <class HT> +struct cons<HT, null_type> { + + typedef HT head_type; + typedef null_type tail_type; + typedef cons<HT, null_type> self_type; + + typedef typename + detail::wrap_non_storeable_type<head_type>::type stored_head_type; + stored_head_type head; + + typename access_traits<stored_head_type>::non_const_type + get_head() { return head; } + + null_type get_tail() { return null_type(); } + + typename access_traits<stored_head_type>::const_type + get_head() const { return head; } + + const null_type get_tail() const { return 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)) { + 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 { + 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 -------------------------------------------------- +template <class T0, class T1, class T2, class T3, class T4, + class T5, class T6, class T7, class T8, class T9> +struct map_tuple_to_cons +{ + typedef cons<T0, + typename map_tuple_to_cons<T1, T2, T3, T4, T5, + T6, T7, T8, T9, null_type>::type + > type; +}; + +// The empty tuple is a null_type +template <> +struct map_tuple_to_cons<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> +{ + typedef null_type type; +}; + +} // end detail + +// ------------------------------------------------------------------- +// -- tuple ------------------------------------------------------ +template <class T0, class T1, class T2, class T3, class T4, + class T5, class T6, class T7, class T8, class T9> + +class tuple : + public detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type +{ +public: + typedef typename + detail::map_tuple_to_cons<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type inherited; + typedef typename inherited::head_type head_type; + typedef typename inherited::tail_type tail_type; + + +// access_traits<T>::parameter_type takes non-reference types as const T& + tuple() {} + + tuple(typename access_traits<T0>::parameter_type t0) + : inherited(t0, detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1) + : inherited(t0, t1, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2) + : inherited(t0, t1, t2, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2, + typename access_traits<T3>::parameter_type t3) + : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2, + typename access_traits<T3>::parameter_type t3, + typename access_traits<T4>::parameter_type t4) + : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2, + typename access_traits<T3>::parameter_type t3, + typename access_traits<T4>::parameter_type t4, + typename access_traits<T5>::parameter_type t5) + : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2, + typename access_traits<T3>::parameter_type t3, + typename access_traits<T4>::parameter_type t4, + typename access_traits<T5>::parameter_type t5, + typename access_traits<T6>::parameter_type t6) + : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2, + typename access_traits<T3>::parameter_type t3, + typename access_traits<T4>::parameter_type t4, + typename access_traits<T5>::parameter_type t5, + typename access_traits<T6>::parameter_type t6, + typename access_traits<T7>::parameter_type t7) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(), + detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2, + typename access_traits<T3>::parameter_type t3, + typename access_traits<T4>::parameter_type t4, + typename access_traits<T5>::parameter_type t5, + typename access_traits<T6>::parameter_type t6, + typename access_traits<T7>::parameter_type t7, + typename access_traits<T8>::parameter_type t8) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {} + + tuple(typename access_traits<T0>::parameter_type t0, + typename access_traits<T1>::parameter_type t1, + typename access_traits<T2>::parameter_type t2, + typename access_traits<T3>::parameter_type t3, + typename access_traits<T4>::parameter_type t4, + typename access_traits<T5>::parameter_type t5, + typename access_traits<T6>::parameter_type t6, + typename access_traits<T7>::parameter_type t7, + typename access_traits<T8>::parameter_type t8, + typename access_traits<T9>::parameter_type t9) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {} + + + template<class U1, class U2> + tuple(const cons<U1, U2>& p) : inherited(p) {} + + template <class U1, class U2> + tuple& operator=(const cons<U1, U2>& k) { + inherited::operator=(k); + return *this; + } + + template <class U1, class U2> + tuple& operator=(const std::pair<U1, U2>& k) { + BOOST_STATIC_ASSERT(length<tuple>::value == 2);// check_length = 2 + this->head = k.first; + this->tail.head = k.second; + return *this; + } + +}; + +// The empty tuple +template <> +class tuple<null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type, null_type> : + public null_type +{ +public: + typedef null_type inherited; +}; + + +// Swallows any assignment (by Doug Gregor) +namespace detail { + +struct swallow_assign { + + template<typename T> + swallow_assign const& operator=(const T&) const { + return *this; + } +}; + +} // namespace detail + +// "ignore" allows tuple positions to be ignored when using "tie". +detail::swallow_assign const ignore = detail::swallow_assign(); + +// --------------------------------------------------------------------------- +// The call_traits for make_tuple +// Honours the reference_wrapper class. + +// Must be instantiated with plain or const plain types (not with references) + +// from template<class T> foo(const T& t) : make_tuple_traits<const T>::type +// from template<class T> foo(T& t) : make_tuple_traits<T>::type + +// Conversions: +// T -> T, +// references -> compile_time_error +// reference_wrapper<T> -> T& +// const reference_wrapper<T> -> T& +// array -> const ref array + + +template<class T> +struct make_tuple_traits { + typedef T type; + + // commented away, see below (JJ) + // typedef typename IF< + // boost::is_function<T>::value, + // T&, + // T>::RET type; + +}; + +// The is_function test was there originally for plain function types, +// which can't be stored as such (we must either store them as references or +// pointers). Such a type could be formed if make_tuple was called with a +// reference to a function. +// But this would mean that a const qualified function type was formed in +// the make_tuple function and hence make_tuple can't take a function +// reference as a parameter, and thus T can't be a function type. +// So is_function test was removed. +// (14.8.3. says that type deduction fails if a cv-qualified function type +// is created. (It only applies for the case of explicitly specifying template +// args, though?)) (JJ) + +template<class T> +struct make_tuple_traits<T&> { + typedef typename + detail::generate_error<T&>:: + do_not_use_with_reference_type error; +}; + +// Arrays can't be stored as plain types; convert them to references. +// All arrays are converted to const. This is because make_tuple takes its +// parameters as const T& and thus the knowledge of the potential +// non-constness of actual argument is lost. +template<class T, int n> struct make_tuple_traits <T[n]> { + typedef const T (&type)[n]; +}; + +template<class T, int n> +struct make_tuple_traits<const T[n]> { + typedef const T (&type)[n]; +}; + +template<class T, int n> struct make_tuple_traits<volatile T[n]> { + typedef const volatile T (&type)[n]; +}; + +template<class T, int n> +struct make_tuple_traits<const volatile T[n]> { + typedef const volatile T (&type)[n]; +}; + +template<class T> +struct make_tuple_traits<reference_wrapper<T> >{ + typedef T& type; +}; + +template<class T> +struct make_tuple_traits<const reference_wrapper<T> >{ + typedef T& type; +}; + + + + +namespace detail { + +// a helper traits to make the make_tuple functions shorter (Vesa Karvonen's +// suggestion) +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 +> +struct make_tuple_mapper { + typedef + tuple<typename make_tuple_traits<T0>::type, + typename make_tuple_traits<T1>::type, + typename make_tuple_traits<T2>::type, + typename make_tuple_traits<T3>::type, + typename make_tuple_traits<T4>::type, + typename make_tuple_traits<T5>::type, + typename make_tuple_traits<T6>::type, + typename make_tuple_traits<T7>::type, + typename make_tuple_traits<T8>::type, + typename make_tuple_traits<T9>::type> type; +}; + +} // end detail + +// -make_tuple function templates ----------------------------------- +inline tuple<> make_tuple() { + return tuple<>(); +} + +template<class T0> +inline typename detail::make_tuple_mapper<T0>::type +make_tuple(const T0& t0) { + typedef typename detail::make_tuple_mapper<T0>::type t; + return t(t0); +} + +template<class T0, class T1> +inline typename detail::make_tuple_mapper<T0, T1>::type +make_tuple(const T0& t0, const T1& t1) { + typedef typename detail::make_tuple_mapper<T0, T1>::type t; + return t(t0, t1); +} + +template<class T0, class T1, class T2> +inline typename detail::make_tuple_mapper<T0, T1, T2>::type +make_tuple(const T0& t0, const T1& t1, const T2& t2) { + typedef typename detail::make_tuple_mapper<T0, T1, T2>::type t; + return t(t0, t1, t2); +} + +template<class T0, class T1, class T2, class T3> +inline typename detail::make_tuple_mapper<T0, T1, T2, T3>::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) { + typedef typename detail::make_tuple_mapper<T0, T1, T2, T3>::type t; + return t(t0, t1, t2, t3); +} + +template<class T0, class T1, class T2, class T3, class T4> +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4) { + typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4>::type t; + return t(t0, t1, t2, t3, t4); +} + +template<class T0, class T1, class T2, class T3, class T4, class T5> +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5) { + typedef typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5>::type t; + return t(t0, t1, t2, t3, t4, t5); +} + +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6> +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6>::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6) { + typedef typename detail::make_tuple_mapper + <T0, T1, T2, T3, T4, T5, T6>::type t; + return t(t0, t1, t2, t3, t4, t5, t6); +} + +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, + class T7> +inline typename detail::make_tuple_mapper<T0, T1, T2, T3, T4, T5, T6, T7>::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7) { + typedef typename detail::make_tuple_mapper + <T0, T1, T2, T3, T4, T5, T6, T7>::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7); +} + +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, + class T7, class T8> +inline typename detail::make_tuple_mapper + <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4, const T5& t5, const T6& t6, const T7& t7, + const T8& t8) { + typedef typename detail::make_tuple_mapper + <T0, T1, T2, T3, T4, T5, T6, T7, T8>::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); +} + +template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, + class T7, class T8, class T9> +inline typename detail::make_tuple_mapper + <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>::type +make_tuple(const T0& t0, 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) { + typedef typename detail::make_tuple_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); +} + + + +// Tie function templates ------------------------------------------------- +template<class T1> +inline tuple<T1&> tie(T1& t1) { + return tuple<T1&> (t1); +} + +template<class T1, class T2> +inline tuple<T1&, T2&> tie(T1& t1, T2& t2) { + return tuple<T1&, T2&> (t1, t2); +} + +template<class T1, class T2, class T3> +inline tuple<T1&, T2&, T3&> tie(T1& t1, T2& t2, T3& t3) { + return tuple<T1&, T2&, T3&> (t1, t2, t3); +} + +template<class T1, class T2, class T3, class T4> +inline tuple<T1&, T2&, T3&, T4&> tie(T1& t1, T2& t2, T3& t3, T4& t4) { + return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4); +} + +template<class T1, class T2, class T3, class T4, class T5> +inline tuple<T1&, T2&, T3&, T4&, T5&> +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) { + return tuple<T1&, T2&, T3&, T4&, T5&> (t1, t2, t3, t4, t5); +} + +template<class T1, class T2, class T3, class T4, class T5, class T6> +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&> +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) { + return tuple<T1&, T2&, T3&, T4&, T5&, T6&> (t1, t2, t3, t4, t5, t6); +} + +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7> +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) { + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> (t1, t2, t3, t4, t5, t6, t7); +} + +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, + class T8> +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) { + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> + (t1, t2, t3, t4, t5, t6, t7, t8); +} + +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, + class T8, class T9> +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, + T9& t9) { + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> + (t1, t2, t3, t4, t5, t6, t7, t8, t9); +} + +template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, + class T8, class T9, class T10> +inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&> +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, + T9& t9, T10& t10) { + return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&> + (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10); +} + +} // end of namespace tuples +} // end of namespace boost + + +#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 new file mode 100644 index 0000000..bb38662 --- /dev/null +++ b/3rdParty/Boost/src/boost/tuple/detail/tuple_basic_no_partial_spec.hpp @@ -0,0 +1,841 @@ +// - 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 <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(); + +} // 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 new file mode 100644 index 0000000..7703597 --- /dev/null +++ b/3rdParty/Boost/src/boost/tuple/tuple.hpp @@ -0,0 +1,90 @@ +// 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) +// +// 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 diff --git a/3rdParty/Boost/src/boost/type_traits/cv_traits.hpp b/3rdParty/Boost/src/boost/type_traits/cv_traits.hpp new file mode 100644 index 0000000..5bd6c4f --- /dev/null +++ b/3rdParty/Boost/src/boost/type_traits/cv_traits.hpp @@ -0,0 +1,24 @@ +// (C) Copyright Dave Abrahams, Steve Cleary, Beman Dawes, Howard +// Hinnant & John Maddock 2000. +// Use, modification and distribution are subject to 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). +// +// See http://www.boost.org/libs/type_traits for most recent version including documentation. +// +// defines traits classes for cv-qualified types: +// is_const, is_volatile, remove_const, remove_volatile, remove_cv. + +#ifndef BOOST_TT_CV_TRAITS_HPP_INCLUDED +#define BOOST_TT_CV_TRAITS_HPP_INCLUDED + +#include <boost/type_traits/add_const.hpp> +#include <boost/type_traits/add_volatile.hpp> +#include <boost/type_traits/add_cv.hpp> +#include <boost/type_traits/is_const.hpp> +#include <boost/type_traits/is_volatile.hpp> +#include <boost/type_traits/remove_const.hpp> +#include <boost/type_traits/remove_volatile.hpp> +#include <boost/type_traits/remove_cv.hpp> + +#endif // BOOST_TT_CV_TRAITS_HPP_INCLUDED diff --git a/3rdParty/Boost/update.sh b/3rdParty/Boost/update.sh index 9af5258..006840b 100755 --- a/3rdParty/Boost/update.sh +++ b/3rdParty/Boost/update.sh @@ -33,6 +33,7 @@ fi boost/unordered_map.hpp \ boost/algorithm/string.hpp \ boost/format.hpp \ + assign/list_of.hpp \ $TARGET_DIR rm -rf $TARGET_DIR/libs/config diff --git a/Sluift/Lua/Value.cpp b/Sluift/Lua/Value.cpp new file mode 100644 index 0000000..b612bd9 --- /dev/null +++ b/Sluift/Lua/Value.cpp @@ -0,0 +1,66 @@ +/*
+ * Copyright (c) 2011 Remko Tronçon
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#include "Value.h"
+
+extern "C" {
+ #include <lualib.h>
+}
+#include <boost/variant/apply_visitor.hpp>
+#include <Swiften/Base/foreach.h>
+
+using namespace Swift;
+using namespace Swift::Lua;
+
+namespace {
+ struct PushVisitor : public boost::static_visitor<> {
+ PushVisitor(lua_State* state) : state(state) {
+ }
+
+ void operator()(const Nil&) const {
+ lua_pushnil(state);
+ }
+
+ void operator()(const bool& b) const {
+ lua_pushboolean(state, b);
+ }
+
+ void operator()(const int& i) const {
+ lua_pushnumber(state, i);
+ }
+
+ void operator()(const std::string& s) const {
+ lua_pushstring(state, s.c_str());
+ }
+
+ void operator()(const std::vector<Value>& list) const {
+ lua_newtable(state);
+ int i = 0;
+ foreach(const Value& value, list) {
+ boost::apply_visitor(PushVisitor(state), value);
+ lua_rawseti(state, -2, i + 1);
+ }
+ }
+
+ void operator()(const std::map<std::string, boost::shared_ptr<Value> >& table) const {
+ lua_createtable(state, 0, table.size());
+ for(std::map<std::string, boost::shared_ptr<Value> >::const_iterator i = table.begin(); i != table.end(); ++i) {
+ boost::apply_visitor(PushVisitor(state), *i->second);
+ lua_setfield(state, -2, i->first.c_str());
+ }
+ }
+
+ lua_State* state;
+ };
+}
+
+namespace Swift { namespace Lua {
+
+void pushValue(lua_State* state, const Value& value) {
+ boost::apply_visitor(PushVisitor(state), value);
+}
+
+}}
diff --git a/Sluift/Lua/Value.h b/Sluift/Lua/Value.h new file mode 100644 index 0000000..9b6da34 --- /dev/null +++ b/Sluift/Lua/Value.h @@ -0,0 +1,34 @@ +/*
+ * Copyright (c) 2011 Remko Tronçon
+ * Licensed under the GNU General Public License v3.
+ * See Documentation/Licenses/GPLv3.txt for more information.
+ */
+
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+#include <boost/variant.hpp>
+#include <boost/shared_ptr.hpp>
+
+struct lua_State;
+
+namespace Swift {
+ namespace Lua {
+ struct Nil {};
+
+ typedef boost::make_recursive_variant<
+ Nil,
+ bool,
+ int,
+ std::string,
+ std::vector< boost::recursive_variant_ >,
+ std::map<std::string, boost::shared_ptr<boost::recursive_variant_> >
+ >::type Value;
+
+ typedef std::map<std::string, boost::shared_ptr<Value> > Table;
+
+ void pushValue(lua_State* state, const Value& value);
+ }
+}
diff --git a/Sluift/SConscript b/Sluift/SConscript index eeb2f24..ec9f690 100644 --- a/Sluift/SConscript +++ b/Sluift/SConscript @@ -6,6 +6,7 @@ if env["SCONS_STAGE"] == "build" : lib_env.UseFlags(env["SWIFTEN_FLAGS"]) lib_env.UseFlags(env["SWIFTEN_DEP_FLAGS"]) sluift_lib = lib_env.StaticLibrary("SluiftCore", [ + "Lua/Value.cpp", "sluift.cpp" ]); diff --git a/Sluift/sluift.cpp b/Sluift/sluift.cpp index da2c93b..d4692a3 100644 --- a/Sluift/sluift.cpp +++ b/Sluift/sluift.cpp @@ -12,6 +12,7 @@ extern "C" { #include <iostream> #include <string> #include <deque> +#include <boost/assign/list_of.hpp> #include <Swiften/Client/Client.h> #include <Swiften/Client/ClientXMLTracer.h> @@ -28,6 +29,7 @@ extern "C" { #include "Watchdog.h" #include "SluiftException.h" #include "ResponseSink.h" +#include "Lua/Value.h" using namespace Swift; @@ -118,7 +120,7 @@ class SluiftClient { client->setSoftwareVersion(name, version, os); } - boost::optional<SoftwareVersion> getSoftwareVersion(const JID& jid) { + SoftwareVersion::ref getSoftwareVersion(const JID& jid) { ResponseSink<SoftwareVersion> sink; GetSoftwareVersionRequest::ref request = GetSoftwareVersionRequest::create(jid, client->getIQRouter()); request->onResponse.connect(boost::ref(sink)); @@ -126,7 +128,7 @@ class SluiftClient { while (!sink.hasResponse()) { eventLoop.runUntilEvents(); } - return sink.getResponsePayload() ? *sink.getResponsePayload() : boost::optional<SoftwareVersion>(); + return sink.getResponsePayload(); } Stanza::ref getNextEvent(int timeout) { @@ -256,15 +258,8 @@ static int sluift_client_set_version(lua_State *L) { static int sluift_client_get_roster(lua_State *L) { try { SluiftClient* client = getClient(L); - std::vector<XMPPRosterItem> items = client->getRoster(); - - lua_createtable(L, 0, items.size()); - foreach(const XMPPRosterItem& item, items) { - lua_createtable(L, 0, 3); - - lua_pushstring(L, item.getName().c_str()); - lua_setfield(L, -2, "name"); - + Lua::Table rosterTable; + foreach(const XMPPRosterItem& item, client->getRoster()) { std::string subscription; switch(item.getSubscription()) { case RosterItemPayload::None: subscription = "none"; break; @@ -273,19 +268,14 @@ static int sluift_client_get_roster(lua_State *L) { case RosterItemPayload::Both: subscription = "both"; break; case RosterItemPayload::Remove: subscription = "remove"; break; } - lua_pushstring(L, subscription.c_str()); - lua_setfield(L, -2, "subscription"); - - std::vector<std::string> groups = item.getGroups(); - lua_createtable(L, groups.size(), 0); - for (size_t i = 0; i < groups.size(); ++i) { - lua_pushstring(L, groups[i].c_str()); - lua_rawseti(L, -2, i + 1); - } - lua_setfield(L, -2, "groups"); - - lua_setfield(L, -2, item.getJID().toString().c_str()); + Lua::Value groups(std::vector<Lua::Value>(item.getGroups().begin(), item.getGroups().end())); + Lua::Table itemTable = boost::assign::map_list_of + ("name", boost::make_shared<Lua::Value>(item.getName())) + ("subscription", boost::make_shared<Lua::Value>(subscription)) + ("groups", boost::make_shared<Lua::Value>(std::vector<Lua::Value>(item.getGroups().begin(), item.getGroups().end()))); + rosterTable[item.getJID().toString()] = boost::make_shared<Lua::Value>(itemTable); } + pushValue(L, rosterTable); return 1; } catch (const SluiftException& e) { @@ -297,16 +287,13 @@ static int sluift_client_get_version(lua_State *L) { try { SluiftClient* client = getClient(L); JID jid(std::string(luaL_checkstring(L, 2))); - - boost::optional<SoftwareVersion> version = client->getSoftwareVersion(jid); + SoftwareVersion::ref version = client->getSoftwareVersion(jid); if (version) { - lua_createtable(L, 0, 3); - lua_pushstring(L, version->getName().c_str()); - lua_setfield(L, -2, "name"); - lua_pushstring(L, version->getVersion().c_str()); - lua_setfield(L, -2, "version"); - lua_pushstring(L, version->getOS().c_str()); - lua_setfield(L, -2, "os"); + Lua::Table result = boost::assign::map_list_of + ("name", boost::make_shared<Lua::Value>(version->getName())) + ("version", boost::make_shared<Lua::Value>(version->getVersion())) + ("os", boost::make_shared<Lua::Value>(version->getOS())); + Lua::pushValue(L, result); } else { lua_pushnil(L); @@ -382,22 +369,18 @@ static int sluift_client_set_options(lua_State* L) { static void pushEvent(lua_State* L, Stanza::ref event) { if (Message::ref message = boost::dynamic_pointer_cast<Message>(event)) { - lua_createtable(L, 0, 3); - lua_pushliteral(L, "message"); - lua_setfield(L, -2, "type"); - lua_pushstring(L, message->getFrom().toString().c_str()); - lua_setfield(L, -2, "from"); - lua_pushstring(L, message->getBody().c_str()); - lua_setfield(L, -2, "body"); + Lua::Table result = boost::assign::map_list_of + ("type", boost::make_shared<Lua::Value>("message")) + ("from", boost::make_shared<Lua::Value>(message->getFrom().toString())) + ("body", boost::make_shared<Lua::Value>(message->getBody())); + Lua::pushValue(L, result); } else if (Presence::ref presence = boost::dynamic_pointer_cast<Presence>(event)) { - lua_createtable(L, 0, 3); - lua_pushliteral(L, "presence"); - lua_setfield(L, -2, "type"); - lua_pushstring(L, presence->getFrom().toString().c_str()); - lua_setfield(L, -2, "from"); - lua_pushstring(L, presence->getStatus().c_str()); - lua_setfield(L, -2, "status"); + Lua::Table result = boost::assign::map_list_of + ("type", boost::make_shared<Lua::Value>("presence")) + ("from", boost::make_shared<Lua::Value>(presence->getFrom().toString())) + ("status", boost::make_shared<Lua::Value>(presence->getStatus())); + Lua::pushValue(L, result); } else { lua_pushnil(L); diff --git a/Swiften/Elements/SoftwareVersion.h b/Swiften/Elements/SoftwareVersion.h index 26d49b1..5863b38 100644 --- a/Swiften/Elements/SoftwareVersion.h +++ b/Swiften/Elements/SoftwareVersion.h @@ -4,8 +4,7 @@ * See Documentation/Licenses/GPLv3.txt for more information. */ -#ifndef SWIFTEN_SoftwareVersion_H -#define SWIFTEN_SoftwareVersion_H +#pragma once #include "Swiften/Elements/Payload.h" #include <string> @@ -13,6 +12,8 @@ namespace Swift { class SoftwareVersion : public Payload { public: + typedef boost::shared_ptr<SoftwareVersion> ref; + SoftwareVersion( const std::string& name = "", const std::string& version = "", @@ -49,5 +50,3 @@ namespace Swift { std::string os_; }; } - -#endif |