| // Boost.Assign library |
| // |
| // Copyright Thorsten Ottosen 2003-2005. 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_PTR_LIST_OF_HPP |
| #define BOOST_ASSIGN_PTR_LIST_OF_HPP |
| |
| #if defined(_MSC_VER) && (_MSC_VER >= 1020) |
| # pragma once |
| #endif |
| |
| #include <boost/assign/list_of.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 <boost/ptr_container/ptr_vector.hpp> |
| |
| #include <boost/preprocessor/repetition/enum_binary_params.hpp> |
| #include <boost/preprocessor/repetition/enum_params.hpp> |
| #include <boost/preprocessor/iteration/local.hpp> |
| |
| namespace boost |
| { |
| |
| namespace assign_detail |
| { |
| ///////////////////////////////////////////////////////////////////////// |
| // Part 1: flexible and efficient interface |
| ///////////////////////////////////////////////////////////////////////// |
| |
| template< class T > |
| class generic_ptr_list : |
| public converter< generic_ptr_list<T>, |
| BOOST_DEDUCED_TYPENAME boost::ptr_vector<T>::iterator > |
| { |
| protected: |
| typedef boost::ptr_vector<T> impl_type; |
| typedef std::auto_ptr<impl_type> release_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: |
| generic_ptr_list() : values_( 32u ) |
| { } |
| |
| generic_ptr_list( release_type r ) : values_(r) |
| { } |
| |
| release_type release() |
| { |
| return values_.release(); |
| } |
| |
| 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(); } |
| |
| public: |
| |
| operator impl_type() const |
| { |
| return values_; |
| } |
| |
| template< template<class,class,class> class Seq, class U, |
| class CA, class A > |
| operator Seq<U,CA,A>() const |
| { |
| Seq<U,CA,A> result; |
| result.transfer( result.end(), values_ ); |
| BOOST_ASSERT( empty() ); |
| return result; |
| } |
| |
| template< class PtrContainer > |
| std::auto_ptr<PtrContainer> convert( const PtrContainer* c ) const |
| { |
| std::auto_ptr<PtrContainer> res( new PtrContainer() ); |
| while( !empty() ) |
| res->insert( res->end(), |
| values_.pop_back().release() ); |
| return res; |
| } |
| |
| template< class PtrContainer > |
| std::auto_ptr<PtrContainer> to_container( const PtrContainer& c ) const |
| { |
| return convert( &c ); |
| } |
| |
| protected: |
| void push_back( T* r ) { values_.push_back( r ); } |
| |
| public: |
| generic_ptr_list& operator()() |
| { |
| this->push_back( new T() ); |
| return *this; |
| } |
| |
| template< class U > |
| generic_ptr_list& operator()( const U& u ) |
| { |
| this->push_back( new T(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_PP_LOCAL_LIMITS (1, BOOST_ASSIGN_MAX_PARAMETERS) |
| #define BOOST_PP_LOCAL_MACRO(n) \ |
| template< class U, BOOST_ASSIGN_PARAMS1(n) > \ |
| generic_ptr_list& operator()(U const& u, BOOST_ASSIGN_PARAMS2(n) ) \ |
| { \ |
| this->push_back( new T(u, BOOST_ASSIGN_PARAMS3(n))); \ |
| return *this; \ |
| } \ |
| /**/ |
| |
| #include BOOST_PP_LOCAL_ITERATE() |
| |
| }; // class 'generic_ptr_list' |
| |
| } // namespace 'assign_detail' |
| |
| namespace assign |
| { |
| template< class T > |
| inline assign_detail::generic_ptr_list<T> |
| ptr_list_of() |
| { |
| return assign_detail::generic_ptr_list<T>()(); |
| } |
| |
| template< class T, class U > |
| inline assign_detail::generic_ptr_list<T> |
| ptr_list_of( const U& t ) |
| { |
| return assign_detail::generic_ptr_list<T>()( 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_ptr_list<T> \ |
| ptr_list_of(U const& u, BOOST_ASSIGN_PARAMS2(n) ) \ |
| { \ |
| return assign_detail::generic_ptr_list<T>()(u, BOOST_ASSIGN_PARAMS3(n)); \ |
| } \ |
| /**/ |
| |
| #include BOOST_PP_LOCAL_ITERATE() |
| |
| |
| } // namespace 'assign' |
| } // namespace 'boost' |
| |
| |
| #undef BOOST_ASSIGN_PARAMS1 |
| #undef BOOST_ASSIGN_PARAMS2 |
| #undef BOOST_ASSIGN_PARAMS3 |
| #undef BOOST_ASSIGN_MAX_PARAMETERS |
| |
| #endif |