{

// 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();

}

: 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);

}

{

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";