diff options
Diffstat (limited to 'boost/assign/ptr_list_of.hpp')
| -rw-r--r-- | boost/assign/ptr_list_of.hpp | 191 |
1 files changed, 191 insertions, 0 deletions
diff --git a/boost/assign/ptr_list_of.hpp b/boost/assign/ptr_list_of.hpp new file mode 100644 index 0000000000..3055ce791b --- /dev/null +++ b/boost/assign/ptr_list_of.hpp @@ -0,0 +1,191 @@ +// 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 |