traits.hpp

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

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

                template<typename Sig>
                struct result
                {
                    typedef
                        typename pass_through<less_equal>::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_equal\<T,U\> \>::::value</tt> is \c true.
                /// \return <tt>pass_through\<less_equal\<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_equal>()(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 <tt>pass_through\<\></tt>
            /// transform.
            template<typename T, typename U>
            struct greater_equal
            {
                typedef proto::expr<proto::tag::greater_equal, args2<T, U> > type;
                typedef type proto_base_expr;

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

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

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

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

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

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

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

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

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

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

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

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

                template<typename Sig>
                struct result
                {