| // 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 |