diff options
Diffstat (limited to '3rdParty/Boost/src/boost/proto/fusion.hpp')
-rw-r--r-- | 3rdParty/Boost/src/boost/proto/fusion.hpp | 720 |
1 files changed, 720 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/proto/fusion.hpp b/3rdParty/Boost/src/boost/proto/fusion.hpp new file mode 100644 index 0000000..21763d3 --- /dev/null +++ b/3rdParty/Boost/src/boost/proto/fusion.hpp @@ -0,0 +1,720 @@ +/////////////////////////////////////////////////////////////////////////////// +/// \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 |