You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
706 lines
21 KiB
706 lines
21 KiB
/*============================================================================= |
|
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
|
|
|