/src/contrib/boost/spirit/home/phoenix/stl/container/container.hpp
http://pythonocc.googlecode.com/ · C++ Header · 706 lines · 518 code · 73 blank · 115 comment · 1 complexity · 56b7b3364856797892079a0131716502 MD5 · raw file
- /*=============================================================================
- 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