#ifndef BOOST_PP_IS_ITERATING /////////////////////////////////////////////////////////////////////////////// /// \file traits.hpp /// Contains definitions for arg\<\>, arg_c\<\>, left\<\>, /// right\<\>, tag_of\<\>, and the helper functions arg(), arg_c(), /// left() and right(). // // 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_ARG_TRAITS_HPP_EAN_04_01_2005 #define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if BOOST_WORKAROUND( BOOST_MSVC, == 1310 ) #define BOOST_PROTO_IS_ARRAY_(T) boost::is_array::type> #else #define BOOST_PROTO_IS_ARRAY_(T) boost::is_array #endif #if BOOST_WORKAROUND( BOOST_MSVC, >= 1400 ) #pragma warning(push) #pragma warning(disable: 4180) // warning C4180: qualifier applied to function type has no meaning; ignored #endif namespace boost { namespace proto { namespace detail { template struct if_vararg {}; template struct if_vararg : T {}; template struct is_callable2_ : mpl::false_ {}; template struct is_callable2_ : mpl::true_ {}; template::value)> struct is_callable_ : is_callable2_ {}; } /// \brief Boolean metafunction which detects whether a type is /// a callable function object type or not. /// /// is_callable\<\> is used by the when\<\> transform /// to determine whether a function type R(A1,A2,...AN) is a /// callable transform or an object transform. (The former are evaluated /// using call\<\> and the later with make\<\>.) If /// is_callable\::::value is \c true, the function type is /// a callable transform; otherwise, it is an object transform. /// /// Unless specialized for a type \c T, is_callable\::::value /// is computed as follows: /// /// \li If \c T is a template type X\, where all \c Yx /// are types for \c x in [0,N], is_callable\::::value /// is is_same\::::value. /// \li If \c T has a nested type \c proto_is_callable_ that is a typedef /// for \c void, is_callable\::::value is \c true. (Note: this is /// the case for any type that derives from \c proto::callable.) /// \li Otherwise, is_callable\::::value is \c false. template struct is_callable : proto::detail::is_callable_ {}; /// INTERNAL ONLY /// template<> struct is_callable : mpl::true_ {}; /// INTERNAL ONLY /// template<> struct is_callable : mpl::false_ {}; #if BOOST_WORKAROUND(__GNUC__, == 3) // work around GCC bug template struct is_callable > : mpl::false_ {}; #endif /// \brief A Boolean metafunction that indicates whether a type requires /// aggregate initialization. /// /// is_aggregate\<\> is used by the make\<\> transform /// to determine how to construct an object of some type \c T, given some /// initialization arguments a0,a1,...aN. /// If is_aggregate\::::value is \c true, then an object of /// type T will be initialized as T t = {a0,a1,...aN};. Otherwise, /// it will be initialized as T t(a0,a1,...aN). template struct is_aggregate : is_pod {}; /// \brief Specialization of is_aggregate\<\> that indicates /// that objects of expr\<\> type require aggregate initialization. template struct is_aggregate > : mpl::true_ {}; namespace result_of { /// \brief A Boolean metafunction that indicates whether a given /// type \c T is a Proto expression type. /// /// If \c T has a nested type \c proto_is_expr_ that is a typedef /// for \c void, is_expr\::::value is \c true. (Note, this /// is the case for proto::expr\<\>, any type that is derived /// from proto::extends\<\> or that uses the /// BOOST_PROTO_EXTENDS() macro.) Otherwise, /// is_expr\::::value is \c false. template struct is_expr : mpl::false_ {}; /// \brief A Boolean metafunction that indicates whether a given /// type \c T is a Proto expression type. /// /// If \c T has a nested type \c proto_is_expr_ that is a typedef /// for \c void, is_expr\::::value is \c true. (Note, this /// is the case for proto::expr\<\>, any type that is derived /// from proto::extends\<\> or that uses the /// BOOST_PROTO_EXTENDS() macro.) Otherwise, /// is_expr\::::value is \c false. template struct is_expr : mpl::true_ {}; /// \brief A metafunction that returns the tag type of a /// Proto expression. template struct tag_of { typedef typename Expr::proto_tag type; }; /// INTERNAL ONLY /// template struct is_ref : mpl::false_ {}; /// INTERNAL ONLY /// template struct is_ref : mpl::true_ {}; /// \brief A metafunction that computes the return type of the \c as_expr() /// function. /// /// The as_expr\<\> metafunction turns types into Proto types, if /// they are not already, by making them Proto terminals held by value if /// possible. Types which are already Proto types are left alone. /// /// This specialization is selected when the type is not yet a Proto type. /// The resulting terminal type is calculated as follows: /// /// If \c T is an array type or a function type, let \c A be T &. /// Otherwise, let \c A be the type \c T stripped of cv-qualifiers. /// Then, the result type as_expr\::::type is /// Domain::apply\< expr\< tag::terminal, args0\ \> \>::::type. template< typename T , typename Domain BOOST_PROTO_FOR_DOXYGEN_ONLY(= default_domain) , typename Void BOOST_PROTO_FOR_DOXYGEN_ONLY(= void) > struct as_expr { typedef mpl::or_ > is_unstorable_; typedef typename mpl::eval_if, remove_cv >::type arg0_; typedef proto::expr > expr_; typedef typename Domain::template apply::type type; typedef type const reference; /// INTERNAL ONLY /// template static reference call(T2 &t) { return Domain::make(expr_::make(t)); } }; /// \brief A metafunction that computes the return type of the \c as_expr() /// function. /// /// The as_expr\<\> metafunction turns types into Proto types, if /// they are not already, by making them Proto terminals held by value if /// possible. Types which are already Proto types are left alone. /// /// This specialization is selected when the type is already a Proto type. /// The result type as_expr\::::type is \c T stripped /// of cv-qualifiers. template struct as_expr { typedef typename T::proto_derived_expr type; typedef T &reference; /// INTERNAL ONLY /// template static reference call(T2 &t) { return t; } }; /// \brief A metafunction that computes the return type of the \c as_arg() /// function. /// /// The as_arg\<\> metafunction turns types into Proto types, if /// they are not already, by making them Proto terminals held by reference. /// Types which are already Proto types are wrapped in proto::ref_\<\>. /// /// This specialization is selected when the type is not yet a Proto type. /// The result type as_arg\::::type is /// Domain::apply\< expr\< tag::terminal, args0\ \> \>::::type. template< typename T , typename Domain BOOST_PROTO_FOR_DOXYGEN_ONLY(= default_domain) , typename Void BOOST_PROTO_FOR_DOXYGEN_ONLY(= void) > struct as_arg { typedef proto::expr > expr_; typedef typename Domain::template apply::type type; /// INTERNAL ONLY /// template static type call(T2 &t) { return Domain::make(expr_::make(t)); } }; /// \brief A metafunction that computes the return type of the \c as_arg() /// function. /// /// The as_arg\<\> metafunction turns types into Proto types, if /// they are not already, by making them Proto terminals held by reference. /// Types which are already Proto types are wrapped in proto::ref_\<\>. /// /// This specialization is selected when the type is already a Proto type. /// The result type as_arg\::::type is /// proto::ref_\. template struct as_arg { typedef ref_ type; /// INTERNAL ONLY /// template static type call(T2 &t) { return type::make(t); } }; /// \brief A metafunction that returns the type of the Nth child /// of a Proto expression, where N is an MPL Integral Constant. /// /// result_of::arg\ is equivalent to /// result_of::arg_c\. template) > struct arg : arg_c {}; // TODO left<> and right<> force the instantiation of Expr. // Couldn't we partially specialize them on proto::expr< T, A > // and ref_< proto::expr< T, A > > and return A::arg0 / A::arg1? /// \brief A metafunction that returns the type of the left child /// of a binary Proto expression. /// /// result_of::left\ is equivalent to /// result_of::arg_c\. template struct left { typedef typename Expr::proto_arg0 wrapped_type; typedef typename unref::type type; typedef typename unref::reference reference; typedef typename unref::const_reference const_reference; }; /// \brief A metafunction that returns the type of the right child /// of a binary Proto expression. /// /// result_of::right\ is equivalent to /// result_of::arg_c\. template struct right { typedef typename Expr::proto_arg1 wrapped_type; typedef typename unref::type type; typedef typename unref::reference reference; typedef typename unref::const_reference const_reference; }; } // namespace result_of namespace op { /// \brief A metafunction for generating terminal expression types, /// a grammar element for matching terminal expressions, and a /// PrimitiveTransform that returns the current expression unchanged. template struct terminal { typedef proto::expr > type; typedef type proto_base_expr; template struct result; template struct result { typedef Expr type; }; /// \param expr The current expression /// \pre matches\ \>::::value is \c true. /// \return \c expr /// \throw nothrow template Expr const &operator ()(Expr const &expr, State const &, Visitor &) const { return expr; } /// INTERNAL ONLY typedef proto::tag::terminal proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating ternary conditional expression types, /// a grammar element for matching ternary conditional expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct if_else_ { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::if_else_ proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; /// INTERNAL ONLY typedef V proto_arg2; }; /// \brief A metafunction for generating unary expression types with a /// specified tag type, /// a grammar element for matching unary expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. /// /// Use unary_expr\<_, _\> as a grammar element to match any /// unary expression. template struct unary_expr { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef Tag proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating binary expression types with a /// specified tag type, /// a grammar element for matching binary expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. /// /// Use binary_expr\<_, _, _\> as a grammar element to match any /// binary expression. template struct binary_expr { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef Tag proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating unary plus expression types, /// a grammar element for matching unary plus expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct posit { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::posit proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating unary minus expression types, /// a grammar element for matching unary minus expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct negate { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::negate proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating defereference expression types, /// a grammar element for matching dereference expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct dereference { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::dereference proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating complement expression types, /// a grammar element for matching complement expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct complement { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::complement proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating address_of expression types, /// a grammar element for matching address_of expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct address_of { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::address_of proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating logical_not expression types, /// a grammar element for matching logical_not expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct logical_not { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::logical_not proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating pre-increment expression types, /// a grammar element for matching pre-increment expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct pre_inc { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::pre_inc proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating pre-decrement expression types, /// a grammar element for matching pre-decrement expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct pre_dec { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::pre_dec proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating post-increment expression types, /// a grammar element for matching post-increment expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct post_inc { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::post_inc proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating post-decrement expression types, /// a grammar element for matching post-decrement expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct post_dec { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::post_dec proto_tag; /// INTERNAL ONLY typedef T proto_arg0; }; /// \brief A metafunction for generating left-shift expression types, /// a grammar element for matching left-shift expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct shift_left { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::shift_left proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating right-shift expression types, /// a grammar element for matching right-shift expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct shift_right { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::shift_right proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating multiplies expression types, /// a grammar element for matching multiplies expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct multiplies { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::multiplies proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating divides expression types, /// a grammar element for matching divides expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct divides { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::divides proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating modulus expression types, /// a grammar element for matching modulus expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct modulus { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::modulus proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating binary plus expression types, /// a grammar element for matching binary plus expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct plus { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::plus proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating binary minus expression types, /// a grammar element for matching binary minus expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct minus { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::minus proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating less expression types, /// a grammar element for matching less expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct less { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::less proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating greater expression types, /// a grammar element for matching greater expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct greater { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::greater proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating less-or-equal expression types, /// a grammar element for matching less-or-equal expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct less_equal { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::less_equal proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating greater-or-equal expression types, /// a grammar element for matching greater-or-equal expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct greater_equal { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::greater_equal proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating equal-to expression types, /// a grammar element for matching equal-to expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct equal_to { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::equal_to proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating not-equal-to expression types, /// a grammar element for matching not-equal-to expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct not_equal_to { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::not_equal_to proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating logical-or expression types, /// a grammar element for matching logical-or expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct logical_or { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::logical_or proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating logical-and expression types, /// a grammar element for matching logical-and expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct logical_and { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::logical_and proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating bitwise-and expression types, /// a grammar element for matching bitwise-and expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct bitwise_and { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::bitwise_and proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating bitwise-or expression types, /// a grammar element for matching bitwise-or expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct bitwise_or { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::bitwise_or proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating bitwise-xor expression types, /// a grammar element for matching bitwise-xor expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct bitwise_xor { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::bitwise_xor proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating comma expression types, /// a grammar element for matching comma expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct comma { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::comma proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; template struct mem_ptr { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::mem_ptr proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating assignment expression types, /// a grammar element for matching assignment expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct assign { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::assign proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating left-shift-assign expression types, /// a grammar element for matching left-shift-assign expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct shift_left_assign { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::shift_left_assign proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating right-shift-assign expression types, /// a grammar element for matching right-shift-assign expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct shift_right_assign { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::shift_right_assign proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating multiplies-assign expression types, /// a grammar element for matching multiplies-assign expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct multiplies_assign { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::multiplies_assign proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating divides-assign expression types, /// a grammar element for matching divides-assign expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct divides_assign { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through::template result::type type; }; /// \param expr The current expression /// \param state The current state /// \param visitor An arbitrary visitor /// \pre matches\ \>::::value is \c true. /// \return pass_through\ \>()(expr, state, visitor) template typename result::type operator ()(Expr const &expr, State const &state, Visitor &visitor) const { return pass_through()(expr, state, visitor); } /// INTERNAL ONLY typedef proto::tag::divides_assign proto_tag; /// INTERNAL ONLY typedef T proto_arg0; /// INTERNAL ONLY typedef U proto_arg1; }; /// \brief A metafunction for generating modulus-assign expression types, /// a grammar element for matching modulus-assign expressions, and a /// PrimitiveTransform that dispatches to the pass_through\<\> /// transform. template struct modulus_assign { typedef proto::expr > type; typedef type proto_base_expr; template struct result { typedef typename pass_through