| /*============================================================================== |
| Copyright (c) 2005-2010 Joel de Guzman |
| Copyright (c) 2010 Thomas Heller |
| |
| 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) |
| ==============================================================================*/ |
| |
| #include <boost/phoenix/core.hpp> |
| #include <boost/phoenix/function.hpp> |
| #include <boost/phoenix/stl/container.hpp> |
| #include <boost/phoenix/stl/algorithm.hpp> |
| |
| #include <vector> |
| |
| #include <iostream> |
| |
| namespace phoenix = boost::phoenix; |
| |
| using phoenix::actor; |
| using phoenix::function; |
| using phoenix::arg_names::arg1; |
| |
| struct size_impl |
| { |
| // result_of protocol: |
| template <typename Sig> |
| struct result; |
| |
| template <typename This, typename Container> |
| struct result<This(Container)> |
| { |
| // Note, remove reference here, because Container can be anything |
| typedef typename boost::remove_reference<Container>::type container_type; |
| |
| // The result will be size_type |
| typedef typename container_type::size_type type; |
| }; |
| |
| template <typename Container> |
| typename result<size_impl(Container const&)>::type |
| operator()(Container const& container) const |
| { |
| return container.size(); |
| } |
| }; |
| |
| template <typename Expr> |
| struct container_actor |
| : actor<Expr> |
| { |
| typedef actor<Expr> base_type; |
| typedef container_actor<Expr> that_type; |
| |
| container_actor( base_type const& base = base_type() ) |
| : base_type( base ) {} |
| |
| typename phoenix::expression::function<phoenix::stl::begin, that_type>::type const |
| begin() const |
| { |
| return phoenix::begin(*this); |
| } |
| |
| typename phoenix::expression::function<phoenix::stl::end, that_type>::type const |
| end() const |
| { |
| return phoenix::end(*this); |
| } |
| |
| typename phoenix::expression::function<size_impl, that_type>::type const |
| size() const |
| { |
| function<size_impl> const f = size_impl(); |
| return f(*this); |
| } |
| |
| typename phoenix::expression::function<phoenix::stl::max_size, that_type>::type const |
| max_size() const |
| { |
| return phoenix::max_size(*this); |
| } |
| |
| typename phoenix::expression::function<phoenix::stl::empty, that_type>::type const |
| empty() const |
| { |
| return phoenix::empty(*this); |
| } |
| |
| template <typename Container> |
| typename phoenix::expression::function<phoenix::impl::swap, that_type, Container>::type const |
| swap(actor<Container> const& expr) const |
| { |
| return phoenix::swap(*this, expr); |
| } |
| }; |
| |
| template <typename Expr> |
| container_actor<Expr> const |
| container( actor<Expr> const& expr ) |
| { |
| return expr; |
| } |
| |
| int main() |
| { |
| container_actor<phoenix::expression::argument<1>::type> const con1; |
| std::vector<int> v; |
| v.push_back(0); |
| v.push_back(1); |
| v.push_back(2); |
| v.push_back(3); |
| |
| std::cout << (container(arg1).size())(v) << " == " << v.size() << "\n"; |
| |
| |
| std::cout << (con1.size())(v) << " == " << v.size() << "\n"; |
| } |