From 182dc1c6cbed6ac2bbe297f856650367e0f12ba7 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Remko=20Tron=C3=A7on?= Date: Tue, 1 Mar 2011 21:57:03 +0100 Subject: Introduce Lua::Value helper. 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 + +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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) +// BCB requires full type definition for is_array<> to work correctly. +#include +#endif + +namespace boost +{ + +// this here is necessary to avoid compiler error in +#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, + ::boost::decay, + ::boost::decay >::type type; + }; + + template< class T, std::size_t sz > + type_traits::yes_type assign_is_array( const array* ); + type_traits::no_type assign_is_array( ... ); + template< class T, class U > + type_traits::yes_type assign_is_pair( const std::pair* ); + 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(this)->begin(); + } + + iterator end() const + { + return static_cast(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( 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::type ar; +#else + Array ar; +#endif + const std::size_t sz = ar.size(); + if( sz < static_cast(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(); + } + }; + + 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& 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& r ) + { + return r == l; + } + + template< class T, class I, class Range > + inline bool operator!=( const converter& l, const Range& r ) + { + return !( l == r ); + } + + template< class T, class I, class Range > + inline bool operator!=( const Range& l, const converter& r ) + { + return !( l == r ); + } + + template< class T, class I, class Range > + inline bool operator<( const converter& 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& r ) + { + return ::boost::iterator_range_detail::less_than( l, r ); + } + + template< class T, class I, class Range > + inline bool operator>( const converter& l, const Range& r ) + { + return r < l; + } + + template< class T, class I, class Range > + inline bool operator>( const Range& l, const converter& r ) + { + return r < l; + } + + template< class T, class I, class Range > + inline bool operator<=( const converter& l, const Range& r ) + { + return !( l > r ); + } + + template< class T, class I, class Range > + inline bool operator<=( const Range& l, const converter& r ) + { + return !( l > r ); + } + + template< class T, class I, class Range > + inline bool operator>=( const converter& l, const Range& r ) + { + return !( l < r ); + } + + template< class T, class I, class Range > + inline bool operator>=( const Range& l, const converter& r ) + { + return !( l < r ); + } + + template< class T, class I, class Elem, class Traits > + inline std::basic_ostream& + operator<<( std::basic_ostream& Os, + const converter& 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::type >, + BOOST_DEDUCED_TYPENAME std::deque::type>::iterator > + { + typedef BOOST_DEDUCED_TYPENAME assign_decay::type Ty; + typedef std::deque 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(); + } + }; + + ///////////////////////////////////////////////////////////////////////// + // 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& l, + const assign_reference& r ) + { + return l.get_ref() < r.get_ref(); + } + + template< class T > + inline bool operator>( const assign_reference& l, + const assign_reference& r ) + { + return l.get_ref() > r.get_ref(); + } + + template< class T > + inline void swap( assign_reference& l, + assign_reference& r ) + { + l.swap( r ); + } + + + + template< class T, int N > + struct static_generic_list : + public converter< static_generic_list, assign_reference* > + { + private: + typedef T internal_value_type; + + public: + typedef assign_reference 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( 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(); + } + + private: + void insert( T& r ) + { + refs_[current_] = r; + ++current_; + } + + static_generic_list(); + + mutable assign_reference refs_[N]; + int current_; + }; + +} // namespace 'assign_detail' + +namespace assign +{ + template< class T > + inline assign_detail::generic_list + list_of() + { + return assign_detail::generic_list()( T() ); + } + + template< class T > + inline assign_detail::generic_list + list_of( const T& t ) + { + return assign_detail::generic_list()( t ); + } + + template< int N, class T > + inline assign_detail::static_generic_list< BOOST_DEDUCED_TYPENAME assign_detail::assign_decay::type,N> + ref_list_of( T& t ) + { + return assign_detail::static_generic_list::type,N>( t ); + } + + template< int N, class T > + inline assign_detail::static_generic_list::type,N> + cref_list_of( const T& t ) + { + return assign_detail::static_generic_list::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 \ + list_of(U const& u, BOOST_ASSIGN_PARAMS2(n) ) \ + { \ + return assign_detail::generic_list()(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 > \ + tuple_list_of(U u, BOOST_ASSIGN_PARAMS2_NO_REF(n) ) \ + { \ + return assign_detail::generic_list< tuple >()( tuple( 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::type, + BOOST_DEDUCED_TYPENAME assign_detail::assign_decay::type + > > + map_list_of( const Key& k, const T& t ) + { + typedef BOOST_DEDUCED_TYPENAME assign_detail::assign_decay::type k_type; + typedef BOOST_DEDUCED_TYPENAME assign_detail::assign_decay::type t_type; + return assign_detail::generic_list< std::pair >()( k, t ); + } + + template< class F, class S > + inline assign_detail::generic_list< std::pair + < + BOOST_DEDUCED_TYPENAME assign_detail::assign_decay::type, + BOOST_DEDUCED_TYPENAME assign_detail::assign_decay::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 // 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 struct IF { typedef Then RET; }; + +template struct IF { + typedef Else RET; +}; + +} // end detail + +// - cons forward declaration ----------------------------------------------- +template 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 struct length; + + + +namespace detail { + +// -- generate error template, referencing to non-existing members of this +// template is used to produce compilation errors intentionally +template +class generate_error; + +// - cons getters -------------------------------------------------------- +// called: get_class::get(aTuple) + +template< int N > +struct get_class { + template + inline static RET get(const cons& 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::get(t.tail); +#else + return get_class::BOOST_NESTED_TEMPLATE get(t.tail); +#endif + } + template + inline static RET get(cons& t) + { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + return get_class::get(t.tail); +#else + return get_class::BOOST_NESTED_TEMPLATE get(t.tail); +#endif + } +}; + +template<> +struct get_class<0> { + template + inline static RET get(const cons& t) + { + return t.head; + } + template + inline static RET get(cons& t) + { + return t.head; + } +}; + +} // end of namespace detail + + +// -cons type accessors ---------------------------------------- +// typename tuples::element::type gets the type of the +// Nth element ot T, first element is at index 0 +// ------------------------------------------------------- + +#ifndef BOOST_NO_CV_SPECIALIZATIONS + +template +struct element +{ +private: + typedef typename T::tail_type Next; +public: + typedef typename element::type type; +}; +template +struct element<0,T> +{ + typedef typename T::head_type type; +}; + +template +struct element +{ +private: + typedef typename T::tail_type Next; + typedef typename element::type unqualified_type; +public: +#if BOOST_WORKAROUND(__BORLANDC__,<0x600) + typedef const unqualified_type type; +#else + typedef typename boost::add_const::type type; +#endif + +}; +template +struct element<0,const T> +{ +#if BOOST_WORKAROUND(__BORLANDC__,<0x600) + typedef const typename T::head_type type; +#else + typedef typename boost::add_const::type type; +#endif +}; + +#else // def BOOST_NO_CV_SPECIALIZATIONS + +namespace detail { + +template +struct element_impl +{ +private: + typedef typename T::tail_type Next; +public: + typedef typename element_impl::type type; +}; + +template +struct element_impl +{ +private: + typedef typename T::tail_type Next; +public: + typedef const typename element_impl::type type; +}; + +template +struct element_impl<0, T, false /* IsConst */> +{ + typedef typename T::head_type type; +}; + +template +struct element_impl<0, T, true /* IsConst */> +{ + typedef const typename T::head_type type; +}; + +} // end of namespace detail + + +template +struct element: + public detail::element_impl::value> +{ +}; + +#endif + + +// -get function templates ----------------------------------------------- +// Usage: get(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 struct access_traits { + typedef const T& const_type; + typedef T& non_const_type; + + typedef const typename boost::remove_cv::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 struct access_traits { + + 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 +inline typename access_traits< + typename element >::type + >::non_const_type +get(cons& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { +#if BOOST_WORKAROUND(__IBMCPP__,==600 ) + return detail::get_class:: +#else + return detail::get_class::BOOST_NESTED_TEMPLATE +#endif + get< + typename access_traits< + typename element >::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 +inline typename access_traits< + typename element >::type + >::const_type +get(const cons& c BOOST_APPEND_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { +#if BOOST_WORKAROUND(__IBMCPP__,==600) + return detail::get_class:: +#else + return detail::get_class::BOOST_NESTED_TEMPLATE +#endif + get< + typename access_traits< + typename element >::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 some_type; // ok +// but: some_type x; // fails + +template class non_storeable_type { + non_storeable_type(); +}; + +template struct wrap_non_storeable_type { + typedef typename IF< + ::boost::is_function::value, non_storeable_type, T + >::RET type; +}; +template <> struct wrap_non_storeable_type { + typedef non_storeable_type type; +}; + +} // detail + +template +struct cons { + + typedef HT head_type; + typedef TT tail_type; + + typedef typename + detail::wrap_non_storeable_type::type stored_head_type; + + stored_head_type head; + tail_type tail; + + typename access_traits::non_const_type + get_head() { return head; } + + typename access_traits::non_const_type + get_tail() { return tail; } + + typename access_traits::const_type + get_head() const { return head; } + + typename access_traits::const_type + get_tail() const { return tail; } + + cons() : head(), tail() {} + // cons() : head(detail::default_arg::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::parameter_type h, + const tail_type& t) + : head (h), tail(t) {} + + template + 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 + 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 + cons( const cons& u ) : head(u.head), tail(u.tail) {} + + template + cons& operator=( const cons& 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 + cons& operator=( const std::pair& u ) { + BOOST_STATIC_ASSERT(length::value == 2); // check length = 2 + head = u.first; tail.head = u.second; return *this; + } + + // get member functions (non-const and const) + template + typename access_traits< + typename element >::type + >::non_const_type + get() { + return boost::tuples::get(*this); // delegate to non-member get + } + + template + typename access_traits< + typename element >::type + >::const_type + get() const { + return boost::tuples::get(*this); // delegate to non-member get + } +}; + +template +struct cons { + + typedef HT head_type; + typedef null_type tail_type; + typedef cons self_type; + + typedef typename + detail::wrap_non_storeable_type::type stored_head_type; + stored_head_type head; + + typename access_traits::non_const_type + get_head() { return head; } + + null_type get_tail() { return null_type(); } + + typename access_traits::const_type + get_head() const { return head; } + + const null_type get_tail() const { return null_type(); } + + // cons() : head(detail::default_arg::f()) {} + cons() : head() {} + + cons(typename access_traits::parameter_type h, + const null_type& = null_type()) + : head (h) {} + + template + 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 + cons( const cons& u ) : head(u.head) {} + + template + cons& operator=(const cons& 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 + typename access_traits< + typename element::type + >::non_const_type + get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) { + return boost::tuples::get(*this); + } + + template + typename access_traits< + typename element::type + >::const_type + get(BOOST_EXPLICIT_TEMPLATE_NON_TYPE(int, N)) const { + return boost::tuples::get(*this); + } + +}; + +// templates for finding out the length of the tuple ------------------- + +template +struct length { + BOOST_STATIC_CONSTANT(int, value = 1 + length::value); +}; + +template<> +struct length > { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + +template<> +struct length const> { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + +template<> +struct length { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + +template<> +struct length { + BOOST_STATIC_CONSTANT(int, value = 0); +}; + +namespace detail { + +// Tuple to cons mapper -------------------------------------------------- +template +struct map_tuple_to_cons +{ + typedef cons::type + > type; +}; + +// The empty tuple is a null_type +template <> +struct map_tuple_to_cons +{ + typedef null_type type; +}; + +} // end detail + +// ------------------------------------------------------------------- +// -- tuple ------------------------------------------------------ +template + +class tuple : + public detail::map_tuple_to_cons::type +{ +public: + typedef typename + detail::map_tuple_to_cons::type inherited; + typedef typename inherited::head_type head_type; + typedef typename inherited::tail_type tail_type; + + +// access_traits::parameter_type takes non-reference types as const T& + tuple() {} + + tuple(typename access_traits::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::parameter_type t0, + typename access_traits::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::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::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::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3) + : inherited(t0, t1, t2, t3, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull(), + detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4) + : inherited(t0, t1, t2, t3, t4, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5) + : inherited(t0, t1, t2, t3, t4, t5, detail::cnull(), detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6) + : inherited(t0, t1, t2, t3, t4, t5, t6, detail::cnull(), + detail::cnull(), detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6, + typename access_traits::parameter_type t7) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, detail::cnull(), + detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6, + typename access_traits::parameter_type t7, + typename access_traits::parameter_type t8) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, detail::cnull()) {} + + tuple(typename access_traits::parameter_type t0, + typename access_traits::parameter_type t1, + typename access_traits::parameter_type t2, + typename access_traits::parameter_type t3, + typename access_traits::parameter_type t4, + typename access_traits::parameter_type t5, + typename access_traits::parameter_type t6, + typename access_traits::parameter_type t7, + typename access_traits::parameter_type t8, + typename access_traits::parameter_type t9) + : inherited(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9) {} + + + template + tuple(const cons& p) : inherited(p) {} + + template + tuple& operator=(const cons& k) { + inherited::operator=(k); + return *this; + } + + template + tuple& operator=(const std::pair& k) { + BOOST_STATIC_ASSERT(length::value == 2);// check_length = 2 + this->head = k.first; + this->tail.head = k.second; + return *this; + } + +}; + +// The empty tuple +template <> +class tuple : + public null_type +{ +public: + typedef null_type inherited; +}; + + +// Swallows any assignment (by Doug Gregor) +namespace detail { + +struct swallow_assign { + + template + 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 foo(const T& t) : make_tuple_traits::type +// from template foo(T& t) : make_tuple_traits::type + +// Conversions: +// T -> T, +// references -> compile_time_error +// reference_wrapper -> T& +// const reference_wrapper -> T& +// array -> const ref array + + +template +struct make_tuple_traits { + typedef T type; + + // commented away, see below (JJ) + // typedef typename IF< + // boost::is_function::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 +struct make_tuple_traits { + typedef typename + detail::generate_error:: + 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 struct make_tuple_traits { + typedef const T (&type)[n]; +}; + +template +struct make_tuple_traits { + typedef const T (&type)[n]; +}; + +template struct make_tuple_traits { + typedef const volatile T (&type)[n]; +}; + +template +struct make_tuple_traits { + typedef const volatile T (&type)[n]; +}; + +template +struct make_tuple_traits >{ + typedef T& type; +}; + +template +struct make_tuple_traits >{ + 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::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type, + typename make_tuple_traits::type> type; +}; + +} // end detail + +// -make_tuple function templates ----------------------------------- +inline tuple<> make_tuple() { + return tuple<>(); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1, t2); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1, t2, t3); +} + +template +inline typename detail::make_tuple_mapper::type +make_tuple(const T0& t0, const T1& t1, const T2& t2, const T3& t3, + const T4& t4) { + typedef typename detail::make_tuple_mapper::type t; + return t(t0, t1, t2, t3, t4); +} + +template +inline typename detail::make_tuple_mapper::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::type t; + return t(t0, t1, t2, t3, t4, t5); +} + +template +inline typename detail::make_tuple_mapper::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 + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6); +} + +template +inline typename detail::make_tuple_mapper::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 + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7); +} + +template +inline typename detail::make_tuple_mapper + ::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 + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7, t8); +} + +template +inline typename detail::make_tuple_mapper + ::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 + ::type t; + return t(t0, t1, t2, t3, t4, t5, t6, t7, t8, t9); +} + + + +// Tie function templates ------------------------------------------------- +template +inline tuple tie(T1& t1) { + return tuple (t1); +} + +template +inline tuple tie(T1& t1, T2& t2) { + return tuple (t1, t2); +} + +template +inline tuple tie(T1& t1, T2& t2, T3& t3) { + return tuple (t1, t2, t3); +} + +template +inline tuple tie(T1& t1, T2& t2, T3& t3, T4& t4) { + return tuple (t1, t2, t3, t4); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) { + return tuple (t1, t2, t3, t4, t5); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6) { + return tuple (t1, t2, t3, t4, t5, t6); +} + +template +inline tuple +tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7) { + return tuple (t1, t2, t3, t4, t5, t6, t7); +} + +template +inline tuple +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); +} + +template +inline tuple +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); +} + +template +inline tuple +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); +} + +} // 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 + +#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 + struct cons; + + namespace detail { + + // Takes a pointer and routes all assignments to whatever it points to + template + struct assign_to_pointee + { + public: + explicit assign_to_pointee(T* p) : ptr(p) {} + + template + assign_to_pointee& operator=(const Other& other) + { + *ptr = other; + return *this; + } + + private: + T* ptr; + }; + + // Swallows any assignment + struct swallow_assign + { + template + swallow_assign const& operator=(const T&) const + { + return *this; + } + }; + + template struct add_const_reference : add_reference::type> {}; + + template + struct init_tail + { + // Each of vc6 and vc7 seem to require a different formulation + // of this return type + template +#if BOOST_WORKAROUND(BOOST_MSVC, < 1300) + static typename add_reference::type>::type +#else + static typename add_const_reference::type +#endif + execute( cons const& u, long ) + { + return u.get_tail(); + } + }; + + template <> + struct init_tail + { + template + static null_type execute( cons const& u, long ) + { + return null_type(); + } + + template + static null_type execute(U const&, ...) + { + return null_type(); + } + private: + template + void execute( cons const&, int); + }; + + template + Other const& + init_head( Other const& u, ... ) + { + return u; + } + + template + typename add_reference::type>::type + init_head( cons 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 + struct cons + { + typedef cons self_type; + typedef Head head_type; + typedef Tail tail_type; + + private: + typedef typename boost::add_reference::type head_ref; + typedef typename boost::add_reference::type tail_ref; + typedef typename detail::add_const_reference::type head_cref; + typedef typename detail::add_const_reference::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 + 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 + 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 + cons( const U& u ) + : head(detail::init_head(u, 0)) + , tail(detail::init_tail::execute(u, 0L)) + { + } + + template + cons& operator=(const Other& other) + { + head = other.head; + tail = other.tail; + return *this; + } + }; + + namespace detail { + + // Determines if the parameter is null_type + template struct is_null_type { enum { RET = 0 }; }; + template<> struct is_null_type { enum { RET = 1 }; }; + + /* Build a cons structure from the given Head and Tail. If both are null_type, + return null_type. */ + template + struct build_cons + { + private: + enum { tail_is_null_type = is_null_type::RET }; + public: + typedef cons RET; + }; + + template<> + struct build_cons + { + 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::RET cons10; + typedef typename detail::build_cons::RET cons9; + typedef typename detail::build_cons::RET cons8; + typedef typename detail::build_cons::RET cons7; + typedef typename detail::build_cons::RET cons6; + typedef typename detail::build_cons::RET cons5; + typedef typename detail::build_cons::RET cons4; + typedef typename detail::build_cons::RET cons3; + typedef typename detail::build_cons::RET cons2; + typedef typename detail::build_cons::RET cons1; + }; + + // Workaround the lack of partial specialization in some compilers + template + struct _element_type + { + template + struct inner + { + private: + typedef typename Tuple::tail_type tail_type; + typedef _element_type next_elt_type; + + public: + typedef typename _element_type::template inner::RET RET; + }; + }; + + template<> + struct _element_type<0> + { + template + struct inner + { + typedef typename Tuple::head_type RET; + }; + }; + + } // namespace detail + + + // Return the Nth type of the given Tuple + template + struct element + { + private: + typedef detail::_element_type nth_type; + + public: + typedef typename nth_type::template inner::RET RET; + typedef RET type; + }; + + namespace detail { + +#if defined(BOOST_MSVC) && (BOOST_MSVC == 1300) + // special workaround for vc7: + + template + struct reference_adder + { + template + struct rebind + { + typedef T& type; + }; + }; + + template <> + struct reference_adder + { + template + struct rebind + { + typedef T type; + }; + }; + + + // Return a reference to the Nth type of the given Tuple + template + struct element_ref + { + private: + typedef typename element::RET elt_type; + enum { is_ref = is_reference::value }; + + public: + typedef reference_adder::rebind::type RET; + typedef RET type; + }; + + // Return a const reference to the Nth type of the given Tuple + template + struct element_const_ref + { + private: + typedef typename element::RET elt_type; + enum { is_ref = is_reference::value }; + + public: + typedef reference_adder::rebind::type RET; + typedef RET type; + }; + +#else // vc7 + + // Return a reference to the Nth type of the given Tuple + template + struct element_ref + { + private: + typedef typename element::RET elt_type; + + public: + typedef typename add_reference::type RET; + typedef RET type; + }; + + // Return a const reference to the Nth type of the given Tuple + template + struct element_const_ref + { + private: + typedef typename element::RET elt_type; + + public: + typedef typename add_reference::type RET; + typedef RET type; + }; +#endif // vc7 + + } // namespace detail + + // Get length of this tuple + template + struct length + { + BOOST_STATIC_CONSTANT(int, value = 1 + length::value); + }; + + template<> struct length > { + BOOST_STATIC_CONSTANT(int, value = 0); + }; + + template<> + struct length + { + BOOST_STATIC_CONSTANT(int, value = 0); + }; + + namespace detail { + + // Reference the Nth element in a tuple and retrieve it with "get" + template + struct get_class + { + template + static inline + typename detail::element_ref >::RET + get(cons& t) + { + return get_class::get(t.tail); + } + + template + static inline + typename detail::element_const_ref >::RET + get(const cons& t) + { + return get_class::get(t.tail); + } + }; + + template<> + struct get_class<0> + { + template + static inline + typename add_reference::type + get(cons& t) + { + return t.head; + } + + template + static inline + typename add_reference::type + get(const cons& 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::cons1 + { + private: + typedef detail::map_tuple_to_cons 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::type t1_cref; + typedef typename detail::add_const_reference::type t2_cref; + typedef typename detail::add_const_reference::type t3_cref; + typedef typename detail::add_const_reference::type t4_cref; + typedef typename detail::add_const_reference::type t5_cref; + typedef typename detail::add_const_reference::type t6_cref; + typedef typename detail::add_const_reference::type t7_cref; + typedef typename detail::add_const_reference::type t8_cref; + typedef typename detail::add_const_reference::type t9_cref; + typedef typename detail::add_const_reference::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 + tuple(const cons& other) : + cons1(other.head, other.tail) + { + } + + template + self_type& operator=(const std::pair& other) + { + this->head = other.first; + this->tail.head = other.second; + return *this; + } + + template + self_type& operator=(const cons& other) + { + this->head = other.head; + this->tail = other.tail; + + return *this; + } + }; + + namespace detail { + + template struct workaround_holder {}; + + } // namespace detail + + template + typename detail::element_ref >::RET + get(cons& t, detail::workaround_holder* = 0) + { + return detail::get_class::get(t); + } + + template + typename detail::element_const_ref >::RET + get(const cons& t, detail::workaround_holder* = 0) + { + return detail::get_class::get(t); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1) + { + return tuple(t1); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2) + { + return tuple(t1, t2); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3) + { + return tuple(t1, t2, t3); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) + { + return tuple(t1, t2, t3, t4); + } + + // Make a tuple + template + inline + tuple + make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) + { + return tuple(t1, t2, t3, t4, t5); + } + + // Make a tuple + template + inline + tuple + 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); + } + + // Make a tuple + template + inline + tuple + 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); + } + + // Make a tuple + template + inline + tuple + 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); + } + + // Make a tuple + template + inline + tuple + 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); + } + + // Make a tuple + template + inline + tuple + 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); + } + + // Tie variables into a tuple + template + inline + tuple > + tie(T1& t1) + { + return make_tuple(detail::assign_to_pointee(&t1)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::assign_to_pointee > + tie(T1& t1, T2& t2) + { + return make_tuple(detail::assign_to_pointee(&t1), + detail::assign_to_pointee(&t2)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3) + { + return make_tuple(detail::assign_to_pointee(&t1), + detail::assign_to_pointee(&t2), + detail::assign_to_pointee(&t3)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4) + { + return make_tuple(detail::assign_to_pointee(&t1), + detail::assign_to_pointee(&t2), + detail::assign_to_pointee(&t3), + detail::assign_to_pointee(&t4)); + } + + // Tie variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5) + { + return make_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 variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6) + { + return make_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 variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee > + tie(T1& t1, T2& t2, T3& t3, T4& t4, T5 &t5, T6 &t6, T7 &t7) + { + return make_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 variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee > + 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), + 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 variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee > + 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), + 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 variables into a tuple + template + inline + tuple, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee, + detail::assign_to_pointee > + 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), + 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)); + } + // "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 +inline typename tuples::access_traits< + typename tuples::element >::type + >::non_const_type +get(tuples::cons& c) { + return tuples::get(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 +inline typename tuples::access_traits< + typename tuples::element >::type + >::const_type +get(const tuples::cons& c) { + return tuples::get(c); +} +#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION +// +// MSVC, using declarations don't mix with templates well, +// so use forwarding functions instead: +// +template +typename tuples::detail::element_ref >::RET +get(tuples::cons& t, tuples::detail::workaround_holder* = 0) +{ + return tuples::detail::get_class::get(t); +} + +template +typename tuples::detail::element_const_ref >::RET +get(const tuples::cons& t, tuples::detail::workaround_holder* = 0) +{ + return tuples::detail::get_class::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 +#include +#include +#include +#include +#include +#include +#include + +#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 +} +#include +#include + +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& 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 >& table) const { + lua_createtable(state, 0, table.size()); + for(std::map >::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 +#include +#include +#include +#include + +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 > + >::type Value; + + typedef std::map > 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 #include #include +#include #include #include @@ -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 getSoftwareVersion(const JID& jid) { + SoftwareVersion::ref getSoftwareVersion(const JID& jid) { ResponseSink 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(); + 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 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 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(item.getGroups().begin(), item.getGroups().end())); + Lua::Table itemTable = boost::assign::map_list_of + ("name", boost::make_shared(item.getName())) + ("subscription", boost::make_shared(subscription)) + ("groups", boost::make_shared(std::vector(item.getGroups().begin(), item.getGroups().end()))); + rosterTable[item.getJID().toString()] = boost::make_shared(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 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(version->getName())) + ("version", boost::make_shared(version->getVersion())) + ("os", boost::make_shared(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(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("message")) + ("from", boost::make_shared(message->getFrom().toString())) + ("body", boost::make_shared(message->getBody())); + Lua::pushValue(L, result); } else if (Presence::ref presence = boost::dynamic_pointer_cast(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("presence")) + ("from", boost::make_shared(presence->getFrom().toString())) + ("status", boost::make_shared(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 @@ -13,6 +12,8 @@ namespace Swift { class SoftwareVersion : public Payload { public: + typedef boost::shared_ptr ref; + SoftwareVersion( const std::string& name = "", const std::string& version = "", @@ -49,5 +50,3 @@ namespace Swift { std::string os_; }; } - -#endif -- cgit v0.10.2-6-g49f6