traits.hpp

Boost provides free peer-reviewed portable C++ source libraries. We emphasize libraries that work

                /// \pre <tt>matches\<Expr, shift_left\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<shift_left\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<shift_left>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct shift_right
            {
                typedef proto::expr<proto::tag::shift_right, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<shift_right>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression
                /// \param state The current state
                /// \param visitor An arbitrary visitor
                /// \pre <tt>matches\<Expr, shift_right\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<shift_right\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<shift_right>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct multiplies
            {
                typedef proto::expr<proto::tag::multiplies, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<multiplies>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression
                /// \param state The current state
                /// \param visitor An arbitrary visitor
                /// \pre <tt>matches\<Expr, multiplies\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<multiplies\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<multiplies>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct divides
            {
                typedef proto::expr<proto::tag::divides, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<divides>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression
                /// \param state The current state
                /// \param visitor An arbitrary visitor
                /// \pre <tt>matches\<Expr, divides\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<divides\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<divides>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct modulus
            {
                typedef proto::expr<proto::tag::modulus, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<modulus>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression
                /// \param state The current state
                /// \param visitor An arbitrary visitor
                /// \pre <tt>matches\<Expr, modulus\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<modulus\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<modulus>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct plus
            {
                typedef proto::expr<proto::tag::plus, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<plus>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression
                /// \param state The current state
                /// \param visitor An arbitrary visitor
                /// \pre <tt>matches\<Expr, plus\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<plus\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<plus>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct minus
            {
                typedef proto::expr<proto::tag::minus, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<minus>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression
                /// \param state The current state
                /// \param visitor An arbitrary visitor
                /// \pre <tt>matches\<Expr, minus\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<minus\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<minus>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct less
            {
                typedef proto::expr<proto::tag::less, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<less>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression
                /// \param state The current state
                /// \param visitor An arbitrary visitor
                /// \pre <tt>matches\<Expr, less\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<less\<T,U\> \>()(expr, state, visitor)</tt>
                template<typename Expr, typename State, typename Visitor>
                typename result<void(Expr, State, Visitor)>::type
                operator ()(Expr const &expr, State const &state, Visitor &visitor) const
                {
                    return pass_through<less>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct greater
            {
                typedef proto::expr<proto::tag::greater, args2<T, U> > type;
                typedef type proto_base_expr;

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<greater>::template result<Sig>::type
                    type;
                };

                /// \param expr The current expression