Chris@16: /*=============================================================================
Chris@16:     Copyright (c) 2004 Angus Leeming
Chris@16:     Copyright (c) 2004 Joel de Guzman
Chris@16: 
Chris@16:     Distributed under the Boost Software License, Version 1.0. (See accompanying
Chris@16:     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
Chris@16: ==============================================================================*/
Chris@16: #ifndef BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
Chris@16: #define BOOST_PHOENIX_STL_CONTAINER_CONTAINER_HPP
Chris@16: 
Chris@16: #include <boost/phoenix/core/limits.hpp>
Chris@16: #include <boost/mpl/and.hpp>
Chris@16: #include <boost/mpl/not.hpp>
Chris@16: #include <boost/mpl/or.hpp>
Chris@16: #include <boost/mpl/void.hpp>
Chris@16: #include <boost/phoenix/stl/container/detail/container.hpp>
Chris@16: #include <boost/phoenix/function/adapt_callable.hpp>
Chris@16: #include <boost/type_traits/is_const.hpp>
Chris@16: 
Chris@16: namespace boost { namespace phoenix
Chris@16: {
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  STL container member functions
Chris@16: //
Chris@16: //      Lazy functions for STL container member functions
Chris@16: //
Chris@16: //      These functions provide a mechanism for the lazy evaluation of the
Chris@16: //      public member functions of the STL containers. For an overview of
Chris@16: //      what is meant by 'lazy evaluation', see the comments in operators.hpp
Chris@16: //      and functions.hpp.
Chris@16: //
Chris@16: //      Lazy functions are provided for all of the member functions of the
Chris@16: //      following containers:
Chris@16: //
Chris@16: //      deque - list - map - multimap - vector.
Chris@16: //
Chris@16: //      Indeed, should *your* class have member functions with the same names
Chris@16: //      and signatures as those listed below, then it will automatically be
Chris@16: //      supported. To summarize, lazy functions are provided for member
Chris@16: //      functions:
Chris@16: //
Chris@16: //          assign - at - back - begin - capacity - clear - empty - end -
Chris@16: //          erase - front - get_allocator - insert - key_comp - max_size -
Chris@16: //          pop_back - pop_front - push_back - push_front - rbegin - rend -
Chris@16: //          reserve - resize . size - splice - value_comp.
Chris@16: //
Chris@16: //      The lazy functions' names are the same as the corresponding member
Chris@16: //      function. Sample usage:
Chris@16: //
Chris@16: //      "Normal" version                 "Lazy" version
Chris@16: //      ----------------                 --------------
Chris@16: //      my_vector.at(5)                  phoenix::at(arg1, 5)
Chris@16: //      my_list.size()                   phoenix::size(arg1)
Chris@16: //      my_vector1.swap(my_vector2)      phoenix::swap(arg1, arg2)
Chris@16: //
Chris@16: //      Notice that member functions with names that clash with a
Chris@16: //      function in stl algorithms are absent. This will be provided
Chris@16: //      in Phoenix's algorithm module.
Chris@16: //
Chris@16: //      No support is provided here for lazy versions of operator+=,
Chris@16: //      operator[] etc. Such operators are not specific to STL containers and
Chris@16: //      lazy versions can therefore be found in operators.hpp.
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: 
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16: //
Chris@16: //  Lazy member function implementaions.
Chris@16: //
Chris@16: //      The structs below provide the guts of the implementation. Thereafter,
Chris@16: //      the corresponding lazy function itself is simply:
Chris@16: //
Chris@16: //          function<stl::assign> const assign = stl::assign();
Chris@16: //
Chris@16: //      The structs provide a nested "result" class template whose
Chris@16: //      "type" typedef enables the lazy function to ascertain the type
Chris@16: //      to be returned when it is invoked.
Chris@16: //
Chris@16: //      They also provide operator() member functions with signatures
Chris@16: //      corresponding to those of the underlying member function of
Chris@16: //      the STL container.
Chris@16: //
Chris@16: ///////////////////////////////////////////////////////////////////////////////
Chris@16:     namespace stl
Chris@16:     {
Chris@16:         struct assign
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <
Chris@16:                 typename This
Chris@16:               , typename C
Chris@16:               , typename Arg1
Chris@16:             >
Chris@16:             struct result<This(C&, Arg1 const &)>
Chris@16:             {
Chris@16:                 typedef typename add_reference<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <
Chris@16:                 typename This
Chris@16:               , typename C
Chris@16:               , typename Arg1
Chris@16:               , typename Arg2
Chris@16:             >
Chris@16:             struct result<This(C&, Arg1, Arg2)>
Chris@16:             {
Chris@16:                 typedef typename add_reference<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <
Chris@16:                 typename This
Chris@16:               , typename C
Chris@16:               , typename Arg1
Chris@16:               , typename Arg2
Chris@16:               , typename Arg3
Chris@16:             >
Chris@16:             struct result<This(C&, Arg1, Arg2, Arg3)>
Chris@16:             {
Chris@16:                 typedef typename add_reference<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C, typename Arg1>
Chris@16:             C& operator()(C& c, Arg1 const & arg1) const
Chris@16:             {
Chris@16:                 c.assign(arg1);
Chris@16:                 return c;
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2>
Chris@16:             C& operator()(C& c, Arg1 arg1, Arg2 arg2) const
Chris@16:             {
Chris@16:                 c.assign(arg1, arg2);
Chris@16:                 return c;
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2, typename Arg3>
Chris@16:             C& operator()(
Chris@16:                 C& c
Chris@16:               , Arg1 arg1
Chris@16:               , Arg2 arg2
Chris@16:               , Arg3 const & arg3
Chris@16:             ) const
Chris@16:             {
Chris@16:                 return c.assign(arg1, arg2, arg3);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct at_impl
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C, typename Index>
Chris@16:             struct result<This(C&, Index)>
Chris@16:             {
Chris@16:                 //typedef typename const_qualified_reference_of<C>::type type;
Chris@16:                 typedef typename C::value_type & type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C, typename Index>
Chris@16:             typename result<at_impl(C&, Index const&)>::type
Chris@16:             operator()(C& c, Index const &i) const
Chris@16:             {
Chris@16:                 return c.at(i);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename This, typename C, typename Index>
Chris@16:             struct result<This(C const&, Index)>
Chris@16:             {
Chris@16:                 typedef typename C::value_type const & type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C, typename Index>
Chris@16:             typename result<at_impl(C const&, Index const&)>::type
Chris@16:             operator()(C const& c, Index const &i) const
Chris@16:             {
Chris@16:                 return c.at(i);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct back
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef
Chris@16:                     typename const_qualified_reference_of<C>::type
Chris@16:                 type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<back(C&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.back();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct begin
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename const_qualified_iterator_of<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<begin(C&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.begin();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct capacity
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename size_type_of<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<capacity(C&)>::type
Chris@16:             operator()(C const& c) const
Chris@16:             {
Chris@16:                 return c.capacity();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct clear
Chris@16:         {
Chris@16:             typedef void result_type;
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             void operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.clear();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct empty
Chris@16:         {
Chris@16:             typedef bool result_type;
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             bool operator()(C const& c) const
Chris@16:             {
Chris@16:                 return c.empty();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct end
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename const_qualified_iterator_of<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<end(C&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.end();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         namespace result_of
Chris@16:         {
Chris@16:             template <typename C, typename Arg1, typename Arg2 = mpl::void_>
Chris@16:             struct erase
Chris@16:             {
Chris@16:                 //  BOOST_MSVC #if branch here in map_erase_result non-
Chris@16:                 //  standard behavior. The return type should be void but
Chris@16:                 //  VC7.1 prefers to return iterator_of<C>. As a result,
Chris@16:                 //  VC7.1 complains of error C2562:
Chris@16:                 //  boost::phoenix::stl::erase::operator() 'void' function
Chris@16:                 //  returning a value. Oh well... :*
Chris@16: 
Chris@16:                 typedef
Chris@16:                     boost::mpl::eval_if_c<
Chris@16:                         boost::is_same<
Chris@16:                             typename remove_reference<Arg1>::type
Chris@16:                           , typename iterator_of<C>::type
Chris@16:                         >::value
Chris@16: #if defined(BOOST_MSVC)// && (BOOST_MSVC <= 1500)
Chris@16:                       , iterator_of<C>
Chris@16: #else
Chris@16:                       , boost::mpl::identity<void>
Chris@16: #endif
Chris@16:                       , size_type_of<C>
Chris@16:                     >
Chris@16:                 map_erase_result;
Chris@16: 
Chris@16:                 typedef typename
Chris@16:                     boost::mpl::eval_if_c<
Chris@16:                         has_mapped_type<C>::value
Chris@16:                       , map_erase_result
Chris@16:                       , iterator_of<C>
Chris@16:                     >::type
Chris@16:                 type;
Chris@16:             };
Chris@16:         }
Chris@16: 
Chris@16:         struct erase
Chris@16:         {
Chris@16:             //  This mouthful can differentiate between the generic erase
Chris@16:             //  functions (Container == std::deque, std::list, std::vector) and
Chris@16:             //  that specific to the two map-types, std::map and std::multimap.
Chris@16:             //
Chris@16:             //  where C is a std::deque, std::list, std::vector:
Chris@16:             //
Chris@16:             //      1) iterator C::erase(iterator where);
Chris@16:             //      2) iterator C::erase(iterator first, iterator last);
Chris@16:             //
Chris@16:             //  where M is a std::map or std::multimap:
Chris@16:             //
Chris@16:             //      3) size_type M::erase(const Key& keyval);
Chris@16:             //      4) void M::erase(iterator where);
Chris@16:             //      5) void M::erase(iterator first, iterator last);
Chris@16: 
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C, typename Arg1>
Chris@16:             struct result<This(C&, Arg1)>
Chris@16:                 : result_of::erase<C, Arg1>
Chris@16:             {};
Chris@16: 
Chris@16:             template <typename This, typename C, typename Arg1, typename Arg2>
Chris@16:             struct result<This(C&, Arg1, Arg2)>
Chris@16:                 : result_of::erase<C, Arg1, Arg2>
Chris@16:             {};
Chris@16: 
Chris@16:             template <typename C, typename Arg1>
Chris@16:             typename stl_impl::disable_if_is_void<
Chris@16:                 typename result_of::erase<C, Arg1>::type
Chris@16:             >::type
Chris@16:             operator()(C& c, Arg1 arg1) const
Chris@16:             {
Chris@16:                 return c.erase(arg1);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1>
Chris@16:             typename stl_impl::enable_if_is_void<
Chris@16:                 typename result_of::erase<C, Arg1>::type
Chris@16:             >::type
Chris@16:             operator()(C& c, Arg1 arg1) const
Chris@16:             {
Chris@16:                 c.erase(arg1);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2>
Chris@16:             typename stl_impl::disable_if_is_void<
Chris@16:                 typename result_of::erase<C, Arg1, Arg2>::type
Chris@16:             >::type
Chris@16:             operator()(C& c, Arg1 arg1, Arg2 arg2) const
Chris@16:             {
Chris@16:                 return c.erase(arg1, arg2);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2>
Chris@16:             typename stl_impl::enable_if_is_void<
Chris@16:                 typename result_of::erase<C, Arg1, Arg2>::type
Chris@16:             >::type
Chris@16:             operator()(C& c, Arg1 arg1, Arg2 arg2) const
Chris@16:             {
Chris@16:                 c.erase(arg1, arg2);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct front
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename const_qualified_reference_of<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<front(C&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.front();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct get_allocator
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename allocator_type_of<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<get_allocator(C const&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.get_allocator();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         namespace result_of
Chris@16:         {
Chris@16:             template <
Chris@16:                 typename C
Chris@16:               , typename Arg1
Chris@16:               , typename Arg2 = mpl::void_
Chris@16:               , typename Arg3 = mpl::void_
Chris@16:             >
Chris@16:             class insert
Chris@16:             {
Chris@16:                 struct pair_iterator_bool
Chris@16:                 {
Chris@16:                     typedef typename std::pair<typename C::iterator, bool> type;
Chris@16:                 };
Chris@16: 
Chris@16:                 typedef
Chris@16:                     boost::mpl::eval_if<
Chris@16:                         map_insert_returns_pair<typename remove_const<C>::type>
Chris@16:                       , pair_iterator_bool
Chris@16:                       , iterator_of<C>
Chris@16:                     >
Chris@16:                 choice_1;
Chris@16: 
Chris@16:                 typedef
Chris@16:                     boost::mpl::eval_if_c<
Chris@16:                         boost::mpl::and_<
Chris@16:                             boost::is_same<Arg3, mpl::void_>
Chris@16:                           , boost::mpl::not_<boost::is_same<Arg1, Arg2> >
Chris@16:                         >::value
Chris@16:                       , iterator_of<C>
Chris@16:                       , boost::mpl::identity<void>
Chris@16:                     >
Chris@16:                 choice_2;
Chris@16: 
Chris@16:             public:
Chris@16: 
Chris@16:                 typedef typename
Chris@16:                     boost::mpl::eval_if_c<
Chris@16:                         boost::is_same<Arg2, mpl::void_>::value
Chris@16:                       , choice_1
Chris@16:                       , choice_2
Chris@16:                     >::type
Chris@16:                 type;
Chris@16:             };
Chris@16:         }
Chris@16: 
Chris@16:         struct insert
Chris@16:         {
Chris@16:             //  This mouthful can differentiate between the generic insert
Chris@16:             //  functions (Container == deque, list, vector) and those
Chris@16:             //  specific to the two map-types, std::map and std::multimap.
Chris@16:             //
Chris@16:             //  where C is a std::deque, std::list, std::vector:
Chris@16:             //
Chris@16:             //      1) iterator C::insert(iterator where, value_type value);
Chris@16:             //      2) void C::insert(
Chris@16:             //          iterator where, size_type count, value_type value);
Chris@16:             //      3) template <typename Iter>
Chris@16:             //         void C::insert(iterator where, Iter first, Iter last);
Chris@16:             //
Chris@16:             //  where M is a std::map and MM is a std::multimap:
Chris@16:             //
Chris@16:             //      4) pair<iterator, bool> M::insert(value_type const&);
Chris@16:             //      5) iterator MM::insert(value_type const&);
Chris@16:             //
Chris@16:             //  where M is a std::map or std::multimap:
Chris@16:             //
Chris@16:             //      6) template <typename Iter>
Chris@16:             //         void M::insert(Iter first, Iter last);
Chris@16: 
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <
Chris@16:                 typename This
Chris@16:               , typename C
Chris@16:               , typename Arg1
Chris@16:             >
Chris@16:             struct result<This(C &, Arg1)>
Chris@16:                 : result_of::insert<C, Arg1>
Chris@16:             {};
Chris@16: 
Chris@16:             template <
Chris@16:                 typename This
Chris@16:               , typename C
Chris@16:               , typename Arg1
Chris@16:               , typename Arg2
Chris@16:             >
Chris@16:             struct result<This(C &, Arg1, Arg2)>
Chris@16:                 : result_of::insert<C, Arg1, Arg2>
Chris@16:             {};
Chris@16: 
Chris@16:             template <
Chris@16:                 typename This
Chris@16:               , typename C
Chris@16:               , typename Arg1
Chris@16:               , typename Arg2
Chris@16:               , typename Arg3
Chris@16:             >
Chris@16:             struct result<This(C &, Arg1, Arg2, Arg3)>
Chris@16:                 : result_of::insert<C, Arg1, Arg2, Arg3>
Chris@16:             {};
Chris@16: 
Chris@16:             template <typename C, typename Arg1>
Chris@16:             typename result<insert(C&, Arg1)>::type
Chris@16:             operator()(C& c, Arg1 arg1) const
Chris@16:             {
Chris@16:                 return c.insert(arg1);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2>
Chris@16:             typename stl_impl::disable_if_is_void<
Chris@16:                 typename result<insert(C&, Arg1, Arg2)>::type
Chris@16:             >::type
Chris@16:             operator()(C& c, Arg1 arg1, Arg2 arg2) const
Chris@16:             {
Chris@16:                 return c.insert(arg1, arg2);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2>
Chris@16:             typename stl_impl::enable_if_is_void<
Chris@16:                 typename result<insert(C&, Arg1, Arg2)>::type
Chris@16:             >::type
Chris@16:             operator()(C& c, Arg1 arg1, Arg2 arg2) const
Chris@16:             {
Chris@16:                 c.insert(arg1, arg2);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2, typename Arg3>
Chris@16:             typename stl_impl::disable_if_is_void<
Chris@16:                 typename result<insert(C&, Arg1, Arg2, Arg3)>::type
Chris@16:             >::type
Chris@16:             operator()(
Chris@16:                 C& c, Arg1 arg1, Arg2 arg2, Arg3 arg3) const
Chris@16:             {
Chris@16:                 return c.insert(arg1, arg2, arg3);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2, typename Arg3>
Chris@16:             typename stl_impl::enable_if_is_void<
Chris@16:                 typename result<insert(C&, Arg1, Arg2, Arg3)>::type
Chris@16:             >::type
Chris@16:             operator()(
Chris@16:                 C& c, Arg1 arg1, Arg2 arg2, Arg3 arg3) const
Chris@16:             {
Chris@16:                 c.insert(arg1, arg2, arg3);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         namespace result_of
Chris@16:         {
Chris@16:             template <typename C>
Chris@16:             struct key_comp
Chris@16:             {
Chris@16:                 typedef typename key_compare_of<C>::type type;
Chris@16:             };
Chris@16:         }
Chris@16: 
Chris@16:         struct key_comp
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:                 : result_of::key_comp<C>
Chris@16:             {};
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result_of::key_comp<C>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.key_comp();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct max_size
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename size_type_of<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<max_size(C const&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.max_size();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct pop_back
Chris@16:         {
Chris@16:             typedef void result_type;
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             void operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.pop_back();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct pop_front
Chris@16:         {
Chris@16:             typedef void result_type;
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             void operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.pop_front();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct push_back
Chris@16:         {
Chris@16:             typedef void result_type;
Chris@16: 
Chris@16:             template <typename C, typename Arg>
Chris@16:             void operator()(C& c, Arg const& data) const
Chris@16:             {
Chris@16:                 return c.push_back(data);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct push_front
Chris@16:         {
Chris@16:             typedef void result_type;
Chris@16: 
Chris@16:             template <typename C, typename Arg>
Chris@16:             void operator()(C& c, Arg const& data) const
Chris@16:             {
Chris@16:                 return c.push_front(data);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct rbegin
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename
Chris@16:                     const_qualified_reverse_iterator_of<C>::type
Chris@16:                 type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<rbegin(C&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.rbegin();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct rend
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename
Chris@16:                     const_qualified_reverse_iterator_of<C>::type
Chris@16:                 type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<rend(C&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.rend();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct reserve
Chris@16:         {
Chris@16:             typedef void result_type;
Chris@16: 
Chris@16:             template <typename C, typename Arg>
Chris@16:             void operator()(C& c, Arg const& count) const
Chris@16:             {
Chris@16:                 c.reserve(count);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct resize
Chris@16:         {
Chris@16:             typedef void result_type;
Chris@16: 
Chris@16:             template <typename C, typename Arg1>
Chris@16:             void operator()(C& c, Arg1 const& arg1) const
Chris@16:             {
Chris@16:                 c.resize(arg1);
Chris@16:             }
Chris@16: 
Chris@16:             template <typename C, typename Arg1, typename Arg2>
Chris@16:             void operator()(C& c, Arg1 const& arg1, Arg2 const& arg2) const
Chris@16:             {
Chris@16:                 c.resize(arg1, arg2);
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:         struct size
Chris@16:         {
Chris@16:             template <typename Sig>
Chris@16:             struct result;
Chris@16: 
Chris@16:             template <typename This, typename C>
Chris@16:             struct result<This(C&)>
Chris@16:             {
Chris@16:                 typedef typename size_type_of<C>::type type;
Chris@16:             };
Chris@16: 
Chris@16:             template <typename C>
Chris@16:             typename result<size(C&)>::type
Chris@16:             operator()(C& c) const
Chris@16:             {
Chris@16:                 return c.size();
Chris@16:             }
Chris@16:         };
Chris@16: 
Chris@16:     struct splice
Chris@16:     {
Chris@16:         typedef void result_type;
Chris@16: 
Chris@16:         template <typename C, typename Arg1, typename Arg2>
Chris@16:         void operator()(C& c, Arg1 arg1, Arg2 &arg2) const
Chris@16:         {
Chris@16:             c.splice(arg1, arg2);
Chris@16:         }
Chris@16: 
Chris@16:         template <
Chris@16:             typename C
Chris@16:           , typename Arg1
Chris@16:           , typename Arg2
Chris@16:           , typename Arg3
Chris@16:         >
Chris@16:         void operator()(
Chris@16:             C& c
Chris@16:           , Arg1 arg1
Chris@16:           , Arg2 & arg2
Chris@16:           , Arg3 arg3
Chris@16:         ) const
Chris@16:         {
Chris@16:             c.splice(arg1, arg2, arg3);
Chris@16:         }
Chris@16: 
Chris@16:         template <
Chris@16:             typename C
Chris@16:           , typename Arg1
Chris@16:           , typename Arg2
Chris@16:           , typename Arg3
Chris@16:           , typename Arg4
Chris@16:         >
Chris@16:         void operator()(
Chris@16:             C c
Chris@16:           , Arg1 arg1
Chris@16:           , Arg2 & arg2
Chris@16:           , Arg3 arg3
Chris@16:           , Arg4 arg4
Chris@16:         ) const
Chris@16:         {
Chris@16:             c.splice(arg1, arg2, arg3, arg4);
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16: 
Chris@16:     namespace result_of
Chris@16:     {
Chris@16:         template <typename C>
Chris@16:         struct value_comp
Chris@16:         {
Chris@16:             typedef typename value_compare_of<C>::type type;
Chris@16:         };
Chris@16:     }
Chris@16: 
Chris@16:     struct value_comp
Chris@16:     {
Chris@16:         template <typename Sig>
Chris@16:         struct result;
Chris@16: 
Chris@16:         template <typename This, typename C>
Chris@16:         struct result<This(C&)>
Chris@16:             : result_of::value_comp<C>
Chris@16:         {};
Chris@16: 
Chris@16:         template <typename C>
Chris@16:         typename result_of::value_comp<C>::type
Chris@16:         operator()(C& c) const
Chris@16:         {
Chris@16:             return c.value_comp();
Chris@16:         }
Chris@16:     };
Chris@16: 
Chris@16: } // namespace stl
Chris@16: 
Chris@16:     ///////////////////////////////////////////////////////////////////////////////
Chris@16:     //
Chris@16:     //  The lazy functions themselves.
Chris@16:     //
Chris@16:     ///////////////////////////////////////////////////////////////////////////////
Chris@16:     namespace adl_barrier
Chris@16:     {
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 3)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(assign, boost::phoenix::stl::assign, 4)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(at, ::boost::phoenix::stl::at_impl, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(back, stl::back, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(begin, stl::begin, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(capacity, stl::capacity, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(clear, stl::clear, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(empty, stl::empty, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(end, stl::end, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(erase, stl::erase, 3)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(front, stl::front, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(get_allocator, stl::get_allocator, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 3)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(insert, stl::insert, 4)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(key_comp, stl::key_comp, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(max_size, stl::max_size, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(pop_back, stl::pop_back, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(pop_front, stl::pop_front, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(push_back, stl::push_back, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(push_front, stl::push_front, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(rbegin, stl::rbegin, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(rend, stl::rend, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(reserve, stl::reserve, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(resize, stl::resize, 3)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(size, stl::size, 1)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 2)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 3)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 4)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(splice, stl::splice, 5)
Chris@16:         BOOST_PHOENIX_ADAPT_CALLABLE(value_comp, stl::value_comp, 1)
Chris@16:     }
Chris@16: 
Chris@16:     using namespace phoenix::adl_barrier;
Chris@16: }} // namespace boost::phoenix
Chris@16: 
Chris@16: #endif // BOOST_PHOENIX_STL_CONTAINERS_HPP