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