| /////////////////////////////////////////////////////////////////////////////// |
| /// \file fusion.hpp |
| /// Make any Proto expression a valid Fusion sequence |
| // |
| // Copyright 2008 Eric Niebler. 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 BOOST_PROTO_FUSION_HPP_EAN_11_04_2006 |
| #define BOOST_PROTO_FUSION_HPP_EAN_11_04_2006 |
| |
| #include <boost/config.hpp> |
| #include <boost/mpl/if.hpp> |
| #include <boost/mpl/bool.hpp> |
| #include <boost/mpl/long.hpp> |
| #include <boost/mpl/sequence_tag_fwd.hpp> |
| #include <boost/utility/enable_if.hpp> |
| #include <boost/fusion/include/is_view.hpp> |
| #include <boost/fusion/include/tag_of_fwd.hpp> |
| #include <boost/fusion/include/category_of.hpp> |
| #include <boost/fusion/include/iterator_base.hpp> |
| #include <boost/fusion/include/intrinsic.hpp> |
| #include <boost/fusion/include/single_view.hpp> |
| #include <boost/fusion/include/transform.hpp> |
| #include <boost/fusion/include/as_list.hpp> |
| #include <boost/fusion/include/is_segmented.hpp> |
| #include <boost/fusion/sequence/comparison/enable_comparison.hpp> |
| #include <boost/proto/proto_fwd.hpp> |
| #include <boost/proto/traits.hpp> |
| #include <boost/proto/eval.hpp> |
| #include <boost/proto/make_expr.hpp> |
| |
| #ifdef BOOST_MSVC |
| #pragma warning(push) |
| #pragma warning(disable : 4510) // default constructor could not be generated |
| #pragma warning(disable : 4512) // assignment operator could not be generated |
| #pragma warning(disable : 4610) // can never be instantiated - user defined constructor required |
| #endif |
| |
| namespace boost { namespace proto |
| { |
| namespace detail |
| { |
| template<typename Expr, long Pos> |
| struct expr_iterator |
| : fusion::iterator_base<expr_iterator<Expr, Pos> > |
| { |
| typedef Expr expr_type; |
| static const long index = Pos; |
| typedef fusion::random_access_traversal_tag category; |
| typedef |
| tag::proto_expr_iterator< |
| typename Expr::proto_tag |
| , typename Expr::proto_domain |
| > |
| fusion_tag; |
| |
| explicit expr_iterator(Expr &e) |
| : expr(e) |
| {} |
| |
| Expr &expr; |
| }; |
| |
| template<typename Tag> |
| struct as_element |
| { |
| template<typename Sig> |
| struct result; |
| |
| template<typename This, typename Expr> |
| struct result<This(Expr)> |
| : result<This(Expr const &)> |
| {}; |
| |
| template<typename This, typename Expr> |
| struct result<This(Expr &)> |
| : mpl::if_c< |
| is_same<Tag, typename Expr::proto_tag>::value |
| , flat_view<Expr> |
| , fusion::single_view<Expr &> |
| > |
| {}; |
| |
| template<typename Expr> |
| typename result<as_element(Expr &)>::type const |
| operator ()(Expr &e) const |
| { |
| return typename result<as_element(Expr &)>::type(e); |
| } |
| |
| template<typename Expr> |
| typename result<as_element(Expr const &)>::type const |
| operator ()(Expr const &e) const |
| { |
| return typename result<as_element(Expr const &)>::type(e); |
| } |
| }; |
| |
| template<typename Expr> |
| struct flat_view |
| : fusion::sequence_base<flat_view<Expr> > |
| { |
| typedef fusion::forward_traversal_tag category; |
| typedef |
| tag::proto_flat_view< |
| typename Expr::proto_tag |
| , typename Expr::proto_domain |
| > |
| fusion_tag; |
| typedef |
| typename fusion::result_of::as_list< |
| typename fusion::result_of::transform< |
| Expr |
| , as_element<typename Expr::proto_tag> |
| >::type |
| >::type |
| segments_type; |
| |
| explicit flat_view(Expr &e) |
| : segs_(fusion::as_list(fusion::transform(e, as_element<typename Expr::proto_tag>()))) |
| {} |
| |
| segments_type segs_; |
| }; |
| } |
| |
| namespace result_of |
| { |
| template<typename Expr> |
| struct flatten |
| : flatten<Expr const &> |
| {}; |
| |
| template<typename Expr> |
| struct flatten<Expr &> |
| { |
| typedef detail::flat_view<Expr> type; |
| }; |
| } |
| |
| namespace functional |
| { |
| /// \brief A PolymorphicFunctionObject type that returns a "flattened" |
| /// view of a Proto expression tree. |
| /// |
| /// A PolymorphicFunctionObject type that returns a "flattened" |
| /// view of a Proto expression tree. For a tree with a top-most node |
| /// tag of type \c T, the elements of the flattened sequence are |
| /// determined by recursing into each child node with the same |
| /// tag type and returning those nodes of different type. So for |
| /// instance, the Proto expression tree corresponding to the |
| /// expression <tt>a | b | c</tt> has a flattened view with elements |
| /// [a, b, c], even though the tree is grouped as |
| /// <tt>((a | b) | c)</tt>. |
| struct flatten |
| { |
| BOOST_PROTO_CALLABLE() |
| |
| template<typename Sig> |
| struct result; |
| |
| template<typename This, typename Expr> |
| struct result<This(Expr)> |
| : result<This(Expr const &)> |
| {}; |
| |
| template<typename This, typename Expr> |
| struct result<This(Expr &)> |
| { |
| typedef proto::detail::flat_view<Expr> type; |
| }; |
| |
| template<typename Expr> |
| proto::detail::flat_view<Expr> const |
| operator ()(Expr &e) const |
| { |
| return proto::detail::flat_view<Expr>(e); |
| } |
| |
| template<typename Expr> |
| proto::detail::flat_view<Expr const> const |
| operator ()(Expr const &e) const |
| { |
| return proto::detail::flat_view<Expr const>(e); |
| } |
| }; |
| } |
| |
| /// \brief A function that returns a "flattened" |
| /// view of a Proto expression tree. |
| /// |
| /// For a tree with a top-most node |
| /// tag of type \c T, the elements of the flattened sequence are |
| /// determined by recursing into each child node with the same |
| /// tag type and returning those nodes of different type. So for |
| /// instance, the Proto expression tree corresponding to the |
| /// expression <tt>a | b | c</tt> has a flattened view with elements |
| /// [a, b, c], even though the tree is grouped as |
| /// <tt>((a | b) | c)</tt>. |
| template<typename Expr> |
| proto::detail::flat_view<Expr> const |
| flatten(Expr &e) |
| { |
| return proto::detail::flat_view<Expr>(e); |
| } |
| |
| /// \overload |
| /// |
| template<typename Expr> |
| proto::detail::flat_view<Expr const> const |
| flatten(Expr const &e) |
| { |
| return proto::detail::flat_view<Expr const>(e); |
| } |
| |
| /// INTERNAL ONLY |
| /// |
| template<typename Context> |
| struct eval_fun |
| : proto::callable |
| { |
| explicit eval_fun(Context &ctx) |
| : ctx_(ctx) |
| {} |
| |
| template<typename Sig> |
| struct result; |
| |
| template<typename This, typename Expr> |
| struct result<This(Expr)> |
| : result<This(Expr const &)> |
| {}; |
| |
| template<typename This, typename Expr> |
| struct result<This(Expr &)> |
| : proto::result_of::eval<Expr, Context> |
| {}; |
| |
| template<typename Expr> |
| typename proto::result_of::eval<Expr, Context>::type |
| operator ()(Expr &e) const |
| { |
| return proto::eval(e, this->ctx_); |
| } |
| |
| template<typename Expr> |
| typename proto::result_of::eval<Expr const, Context>::type |
| operator ()(Expr const &e) const |
| { |
| return proto::eval(e, this->ctx_); |
| } |
| |
| private: |
| Context &ctx_; |
| }; |
| |
| /// INTERNAL ONLY |
| /// |
| template<typename Context> |
| struct is_callable<eval_fun<Context> > |
| : mpl::true_ |
| {}; |
| }} |
| |
| namespace boost { namespace fusion |
| { |
| namespace extension |
| { |
| template<typename Tag> |
| struct is_sequence_impl; |
| |
| template<typename Tag, typename Domain> |
| struct is_sequence_impl<proto::tag::proto_flat_view<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| : mpl::true_ |
| {}; |
| }; |
| |
| template<typename Tag, typename Domain> |
| struct is_sequence_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| : mpl::true_ |
| {}; |
| }; |
| |
| template<typename Tag> |
| struct is_view_impl; |
| |
| template<typename Tag, typename Domain> |
| struct is_view_impl<proto::tag::proto_flat_view<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| : mpl::true_ |
| {}; |
| }; |
| |
| template<typename Tag, typename Domain> |
| struct is_view_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| : mpl::false_ |
| {}; |
| }; |
| |
| template<typename Tag> |
| struct value_of_impl; |
| |
| template<typename Tag, typename Domain> |
| struct value_of_impl<proto::tag::proto_expr_iterator<Tag, Domain> > |
| { |
| template< |
| typename Iterator |
| , long Arity = proto::arity_of<typename Iterator::expr_type>::value |
| > |
| struct apply |
| { |
| typedef |
| typename proto::result_of::child_c< |
| typename Iterator::expr_type |
| , Iterator::index |
| >::value_type |
| type; |
| }; |
| |
| template<typename Iterator> |
| struct apply<Iterator, 0> |
| { |
| typedef |
| typename proto::result_of::value< |
| typename Iterator::expr_type |
| >::value_type |
| type; |
| }; |
| }; |
| |
| template<typename Tag> |
| struct deref_impl; |
| |
| template<typename Tag, typename Domain> |
| struct deref_impl<proto::tag::proto_expr_iterator<Tag, Domain> > |
| { |
| template< |
| typename Iterator |
| , long Arity = proto::arity_of<typename Iterator::expr_type>::value |
| > |
| struct apply |
| { |
| typedef |
| typename proto::result_of::child_c< |
| typename Iterator::expr_type & |
| , Iterator::index |
| >::type |
| type; |
| |
| static type call(Iterator const &iter) |
| { |
| return proto::child_c<Iterator::index>(iter.expr); |
| } |
| }; |
| |
| template<typename Iterator> |
| struct apply<Iterator, 0> |
| { |
| typedef |
| typename proto::result_of::value< |
| typename Iterator::expr_type & |
| >::type |
| type; |
| |
| static type call(Iterator const &iter) |
| { |
| return proto::value(iter.expr); |
| } |
| }; |
| }; |
| |
| template<typename Tag> |
| struct advance_impl; |
| |
| template<typename Tag, typename Domain> |
| struct advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> > |
| { |
| template<typename Iterator, typename N> |
| struct apply |
| { |
| typedef |
| proto::detail::expr_iterator< |
| typename Iterator::expr_type |
| , Iterator::index + N::value |
| > |
| type; |
| |
| static type call(Iterator const &iter) |
| { |
| return type(iter.expr); |
| } |
| }; |
| }; |
| |
| template<typename Tag> |
| struct distance_impl; |
| |
| template<typename Tag, typename Domain> |
| struct distance_impl<proto::tag::proto_expr_iterator<Tag, Domain> > |
| { |
| template<typename IteratorFrom, typename IteratorTo> |
| struct apply |
| : mpl::long_<IteratorTo::index - IteratorFrom::index> |
| {}; |
| }; |
| |
| template<typename Tag> |
| struct next_impl; |
| |
| template<typename Tag, typename Domain> |
| struct next_impl<proto::tag::proto_expr_iterator<Tag, Domain> > |
| { |
| template<typename Iterator> |
| struct apply |
| : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<1> > |
| {}; |
| }; |
| |
| template<typename Tag> |
| struct prior_impl; |
| |
| template<typename Tag, typename Domain> |
| struct prior_impl<proto::tag::proto_expr_iterator<Tag, Domain> > |
| { |
| template<typename Iterator> |
| struct apply |
| : advance_impl<proto::tag::proto_expr_iterator<Tag, Domain> >::template apply<Iterator, mpl::long_<-1> > |
| {}; |
| }; |
| |
| template<typename Tag> |
| struct category_of_impl; |
| |
| template<typename Tag, typename Domain> |
| struct category_of_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| { |
| typedef random_access_traversal_tag type; |
| }; |
| }; |
| |
| template<typename Tag> |
| struct size_impl; |
| |
| template<typename Tag, typename Domain> |
| struct size_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| : mpl::long_<0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c> |
| {}; |
| }; |
| |
| template<typename Tag> |
| struct begin_impl; |
| |
| template<typename Tag, typename Domain> |
| struct begin_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| { |
| typedef proto::detail::expr_iterator<Sequence, 0> type; |
| |
| static type call(Sequence &seq) |
| { |
| return type(seq); |
| } |
| }; |
| }; |
| |
| template<typename Tag> |
| struct end_impl; |
| |
| template<typename Tag, typename Domain> |
| struct end_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| { |
| typedef |
| proto::detail::expr_iterator< |
| Sequence |
| , 0 == Sequence::proto_arity_c ? 1 : Sequence::proto_arity_c |
| > |
| type; |
| |
| static type call(Sequence &seq) |
| { |
| return type(seq); |
| } |
| }; |
| }; |
| |
| template<typename Tag> |
| struct value_at_impl; |
| |
| template<typename Tag, typename Domain> |
| struct value_at_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template< |
| typename Sequence |
| , typename Index |
| , long Arity = proto::arity_of<Sequence>::value |
| > |
| struct apply |
| { |
| typedef |
| typename proto::result_of::child_c< |
| Sequence |
| , Index::value |
| >::value_type |
| type; |
| }; |
| |
| template<typename Sequence, typename Index> |
| struct apply<Sequence, Index, 0> |
| { |
| typedef |
| typename proto::result_of::value< |
| Sequence |
| >::value_type |
| type; |
| }; |
| }; |
| |
| template<typename Tag> |
| struct at_impl; |
| |
| template<typename Tag, typename Domain> |
| struct at_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template< |
| typename Sequence |
| , typename Index |
| , long Arity = proto::arity_of<Sequence>::value |
| > |
| struct apply |
| { |
| typedef |
| typename proto::result_of::child_c< |
| Sequence & |
| , Index::value |
| >::type |
| type; |
| |
| static type call(Sequence &seq) |
| { |
| return proto::child_c<Index::value>(seq); |
| } |
| }; |
| |
| template<typename Sequence, typename Index> |
| struct apply<Sequence, Index, 0> |
| { |
| typedef |
| typename proto::result_of::value< |
| Sequence & |
| >::type |
| type; |
| |
| static type call(Sequence &seq) |
| { |
| return proto::value(seq); |
| } |
| }; |
| }; |
| |
| template<typename Tag> |
| struct convert_impl; |
| |
| template<typename Tag, typename Domain> |
| struct convert_impl<proto::tag::proto_expr<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| { |
| typedef |
| typename proto::result_of::unpack_expr< |
| Tag |
| , Domain |
| , Sequence |
| >::type |
| type; |
| |
| static type call(Sequence& seq) |
| { |
| return proto::unpack_expr<Tag, Domain>(seq); |
| } |
| }; |
| }; |
| |
| template<typename Tag, typename Domain> |
| struct convert_impl<proto::tag::proto_flat_view<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| { |
| typedef |
| typename proto::result_of::unpack_expr< |
| Tag |
| , Domain |
| , Sequence |
| >::type |
| type; |
| |
| static type call(Sequence& seq) |
| { |
| return proto::unpack_expr<Tag, Domain>(seq); |
| } |
| }; |
| }; |
| |
| template<typename Tag> |
| struct is_segmented_impl; |
| |
| template<typename Tag, typename Domain> |
| struct is_segmented_impl<proto::tag::proto_flat_view<Tag, Domain> > |
| { |
| template<typename Iterator> |
| struct apply |
| : mpl::true_ |
| {}; |
| }; |
| |
| template<typename Tag> |
| struct segments_impl; |
| |
| template<typename Tag, typename Domain> |
| struct segments_impl<proto::tag::proto_flat_view<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| { |
| typedef typename Sequence::segments_type const &type; |
| |
| static type call(Sequence &sequence) |
| { |
| return sequence.segs_; |
| } |
| }; |
| }; |
| |
| template<typename Tag, typename Domain> |
| struct category_of_impl<proto::tag::proto_flat_view<Tag, Domain> > |
| { |
| template<typename Sequence> |
| struct apply |
| { |
| typedef forward_traversal_tag type; |
| }; |
| }; |
| } |
| |
| namespace traits |
| { |
| template<typename Seq1, typename Seq2> |
| struct enable_equality< |
| Seq1 |
| , Seq2 |
| , typename enable_if_c< |
| mpl::or_< |
| proto::is_expr<Seq1> |
| , proto::is_expr<Seq2> |
| >::value |
| >::type |
| > |
| : mpl::false_ |
| {}; |
| |
| template<typename Seq1, typename Seq2> |
| struct enable_comparison< |
| Seq1 |
| , Seq2 |
| , typename enable_if_c< |
| mpl::or_< |
| proto::is_expr<Seq1> |
| , proto::is_expr<Seq2> |
| >::value |
| >::type |
| > |
| : mpl::false_ |
| {}; |
| } |
| }} |
| |
| namespace boost { namespace mpl |
| { |
| template<typename Tag, typename Args, long Arity> |
| struct sequence_tag< proto::expr<Tag, Args, Arity> > |
| { |
| typedef fusion::fusion_sequence_tag type; |
| }; |
| |
| template<typename Tag, typename Args, long Arity> |
| struct sequence_tag< proto::basic_expr<Tag, Args, Arity> > |
| { |
| typedef fusion::fusion_sequence_tag type; |
| }; |
| }} |
| |
| #ifdef BOOST_MSVC |
| #pragma warning(pop) |
| #endif |
| |
| #endif |
