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