proto_fwd.hpp

来自「Boost provides free peer-reviewed portab」· HPP 代码 · 共 723 行 · 第 1/2 页

        template<
            typename Tag
          , typename DomainOrA0
            BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
                BOOST_PROTO_MAX_ARITY
              , typename A
              , = void BOOST_PP_INTERCEPT
            )
          , typename Void = void
        >
        struct make_expr;

        template<typename Tag, typename DomainOrSequence, typename SequenceOrVoid = void, typename Void = void>
        struct unpack_expr;

        template<typename T, typename Void = void>
        struct is_ref;

        template<typename T, typename Void = void>
        struct is_expr;

        template<typename T, typename Void = void>
        struct is_domain;

        template<typename Expr>
        struct tag_of;

        template<typename T, typename Void = void>
        struct domain_of;

        template<typename Expr, typename Grammar>
        struct matches;
    }

    using proto::result_of::is_ref;
    using proto::result_of::is_expr;
    using proto::result_of::is_domain;
    using proto::result_of::tag_of;
    using proto::result_of::domain_of;
    using proto::result_of::matches;

    namespace op
    {
        // Generic expression generators
        template<typename Tag, typename Arg>
        struct unary_expr;

        template<typename Tag, typename Left, typename Right>
        struct binary_expr;

        template<typename Tag, BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void), typename Dummy = void>
        struct nary_expr;

        // Specific expression generators, for convenience
        template<typename T> struct terminal;
        template<typename T> struct posit;
        template<typename T> struct negate;
        template<typename T> struct dereference;
        template<typename T> struct complement;
        template<typename T> struct address_of;
        template<typename T> struct logical_not;
        template<typename T> struct pre_inc;
        template<typename T> struct pre_dec;
        template<typename T> struct post_inc;
        template<typename T> struct post_dec;

        template<typename T, typename U> struct shift_left;
        template<typename T, typename U> struct shift_right;
        template<typename T, typename U> struct multiplies;
        template<typename T, typename U> struct divides;
        template<typename T, typename U> struct modulus;
        template<typename T, typename U> struct plus;
        template<typename T, typename U> struct minus;
        template<typename T, typename U> struct less;
        template<typename T, typename U> struct greater;
        template<typename T, typename U> struct less_equal;
        template<typename T, typename U> struct greater_equal;
        template<typename T, typename U> struct equal_to;
        template<typename T, typename U> struct not_equal_to;
        template<typename T, typename U> struct logical_or;
        template<typename T, typename U> struct logical_and;
        template<typename T, typename U> struct bitwise_and;
        template<typename T, typename U> struct bitwise_or;
        template<typename T, typename U> struct bitwise_xor;
        template<typename T, typename U> struct comma;
        template<typename T, typename U> struct mem_ptr;

        template<typename T, typename U> struct assign;
        template<typename T, typename U> struct shift_left_assign;
        template<typename T, typename U> struct shift_right_assign;
        template<typename T, typename U> struct multiplies_assign;
        template<typename T, typename U> struct divides_assign;
        template<typename T, typename U> struct modulus_assign;
        template<typename T, typename U> struct plus_assign;
        template<typename T, typename U> struct minus_assign;
        template<typename T, typename U> struct bitwise_and_assign;
        template<typename T, typename U> struct bitwise_or_assign;
        template<typename T, typename U> struct bitwise_xor_assign;
        template<typename T, typename U> struct subscript;
        template<typename T, typename U, typename V> struct if_else_;

        template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void), typename Dummy = void>
        struct function;
    }

    using namespace op;

    namespace functional
    {
        struct left;
        struct right;
        struct unref;
        struct eval;
        struct deep_copy;

        template<typename Domain = default_domain>
        struct as_expr;

        template<typename Domain = default_domain>
        struct as_arg;

        template<typename N = mpl::long_<0> >
        struct arg;

        template<long N>
        struct arg_c;

        template<typename Tag, typename Domain = deduce_domain>
        struct make_expr;

        template<typename Tag, typename Domain = deduce_domain>
        struct unpack_expr;

        template<typename Tag, typename Domain = deduce_domain>
        struct unfused_expr_fun;

        template<typename Tag, typename Domain = deduce_domain>
        struct unfused_expr;

        typedef make_expr<tag::terminal>            make_terminal;
        typedef make_expr<tag::posit>               make_posit;
        typedef make_expr<tag::negate>              make_negate;
        typedef make_expr<tag::dereference>         make_dereference;
        typedef make_expr<tag::complement>          make_complement;
        typedef make_expr<tag::address_of>          make_address_of;
        typedef make_expr<tag::logical_not>         make_logical_not;
        typedef make_expr<tag::pre_inc>             make_pre_inc;
        typedef make_expr<tag::pre_dec>             make_pre_dec;
        typedef make_expr<tag::post_inc>            make_post_inc;
        typedef make_expr<tag::post_dec>            make_post_dec;
        typedef make_expr<tag::shift_left>          make_shift_left;
        typedef make_expr<tag::shift_right>         make_shift_right;
        typedef make_expr<tag::multiplies>          make_multiplies;
        typedef make_expr<tag::divides>             make_divides;
        typedef make_expr<tag::modulus>             make_modulus;
        typedef make_expr<tag::plus>                make_plus;
        typedef make_expr<tag::minus>               make_minus;
        typedef make_expr<tag::less>                make_less;
        typedef make_expr<tag::greater>             make_greater;
        typedef make_expr<tag::less_equal>          make_less_equal;
        typedef make_expr<tag::greater_equal>       make_greater_equal;
        typedef make_expr<tag::equal_to>            make_equal_to;
        typedef make_expr<tag::not_equal_to>        make_not_equal_to;
        typedef make_expr<tag::logical_or>          make_logical_or;
        typedef make_expr<tag::logical_and>         make_logical_and;
        typedef make_expr<tag::bitwise_and>         make_bitwise_and;
        typedef make_expr<tag::bitwise_or>          make_bitwise_or;
        typedef make_expr<tag::bitwise_xor>         make_bitwise_xor;
        typedef make_expr<tag::comma>               make_comma;
        typedef make_expr<tag::mem_ptr>             make_mem_ptr;
        typedef make_expr<tag::assign>              make_assign;
        typedef make_expr<tag::shift_left_assign>   make_shift_left_assign;
        typedef make_expr<tag::shift_right_assign>  make_shift_right_assign;
        typedef make_expr<tag::multiplies_assign>   make_multiplies_assign;
        typedef make_expr<tag::divides_assign>      make_divides_assign;
        typedef make_expr<tag::modulus_assign>      make_modulus_assign;
        typedef make_expr<tag::plus_assign>         make_plus_assign;
        typedef make_expr<tag::minus_assign>        make_minus_assign;
        typedef make_expr<tag::bitwise_and_assign>  make_bitwise_and_assign;
        typedef make_expr<tag::bitwise_or_assign>   make_bitwise_or_assign;
        typedef make_expr<tag::bitwise_xor_assign>  make_bitwise_xor_assign;
        typedef make_expr<tag::subscript>           make_subscript;
        typedef make_expr<tag::if_else_>            make_if_else;
        typedef make_expr<tag::function>            make_function;

        struct flatten;
        struct pop_front;
        struct reverse;
    }

    typedef functional::make_terminal               _make_terminal;
    typedef functional::make_posit                  _make_posit;
    typedef functional::make_negate                 _make_negate;
    typedef functional::make_dereference            _make_dereference;
    typedef functional::make_complement             _make_complement;
    typedef functional::make_address_of             _make_address_of;
    typedef functional::make_logical_not            _make_logical_not;
    typedef functional::make_pre_inc                _make_pre_inc;
    typedef functional::make_pre_dec                _make_pre_dec;
    typedef functional::make_post_inc               _make_post_inc;
    typedef functional::make_post_dec               _make_post_dec;
    typedef functional::make_shift_left             _make_shift_left;
    typedef functional::make_shift_right            _make_shift_right;
    typedef functional::make_multiplies             _make_multiplies;
    typedef functional::make_divides                _make_divides;
    typedef functional::make_modulus                _make_modulus;
    typedef functional::make_plus                   _make_plus;
    typedef functional::make_minus                  _make_minus;
    typedef functional::make_less                   _make_less;
    typedef functional::make_greater                _make_greater;
    typedef functional::make_less_equal             _make_less_equal;
    typedef functional::make_greater_equal          _make_greater_equal;
    typedef functional::make_equal_to               _make_equal_to;
    typedef functional::make_not_equal_to           _make_not_equal_to;
    typedef functional::make_logical_or             _make_logical_or;
    typedef functional::make_logical_and            _make_logical_and;
    typedef functional::make_bitwise_and            _make_bitwise_and;
    typedef functional::make_bitwise_or             _make_bitwise_or;
    typedef functional::make_bitwise_xor            _make_bitwise_xor;
    typedef functional::make_comma                  _make_comma;
    typedef functional::make_mem_ptr                _make_mem_ptr;
    typedef functional::make_assign                 _make_assign;
    typedef functional::make_shift_left_assign      _make_shift_left_assign;
    typedef functional::make_shift_right_assign     _make_shift_right_assign;
    typedef functional::make_multiplies_assign      _make_multiplies_assign;
    typedef functional::make_divides_assign         _make_divides_assign;
    typedef functional::make_modulus_assign         _make_modulus_assign;
    typedef functional::make_plus_assign            _make_plus_assign;
    typedef functional::make_minus_assign           _make_minus_assign;
    typedef functional::make_bitwise_and_assign     _make_bitwise_and_assign;
    typedef functional::make_bitwise_or_assign      _make_bitwise_or_assign;
    typedef functional::make_bitwise_xor_assign     _make_bitwise_xor_assign;
    typedef functional::make_subscript              _make_subscript;
    typedef functional::make_if_else                _make_if_else;
    typedef functional::make_function               _make_function;

    typedef functional::flatten     _flatten;
    typedef functional::pop_front   _pop_front;
    typedef functional::reverse     _reverse;
    typedef functional::deep_copy   _eval;
    typedef functional::deep_copy   _deep_copy;

    template<typename T>
    struct is_callable;

    template<typename T>
    struct is_aggregate;

    namespace transform
    {
        #define BOOST_PROTO_CALLABLE() typedef void proto_is_callable_;

        struct callable
        {
            BOOST_PROTO_CALLABLE()
        };

        template<typename Grammar, typename Fun = Grammar>
        struct when;

        template<typename Fun>
        struct otherwise;

        template<typename Fun>
        struct call;

        template<typename Fun>
        struct make;

        template<typename Fun>
        struct bind;

        template<typename Sequence, typename State, typename Fun>
        struct fold;

        template<typename Sequence, typename State, typename Fun>
        struct reverse_fold;

        // BUGBUG can we replace fold_tree with fold<flatten(_), state, fun> ?
        template<typename Sequence, typename State, typename Fun>
        struct fold_tree;

        template<typename Sequence, typename State, typename Fun>
        struct reverse_fold_tree;

        template<typename Grammar>
        struct pass_through;

        struct expr;
        struct state;
        struct visitor;

        template<int I>
        struct arg_c;

        typedef arg_c<0> arg0;
        typedef arg_c<1> arg1;
        typedef arg_c<2> arg2;
        typedef arg_c<3> arg3;
        typedef arg_c<4> arg4;
        typedef arg_c<5> arg5;
        typedef arg_c<6> arg6;
        typedef arg_c<7> arg7;
        typedef arg_c<8> arg8;
        typedef arg_c<9> arg9;

        typedef arg0 arg;
        typedef arg0 left;
        typedef arg1 right;

        struct _ref;
    }

    using transform::when;
    using transform::call;
    using transform::make;
    using transform::bind;
    using transform::fold;
    using transform::otherwise;
    using transform::reverse_fold;
    using transform::fold_tree;
    using transform::reverse_fold_tree;
    using transform::callable;
    using transform::pass_through;

    typedef transform::expr     _expr;
    typedef transform::state    _state;
    typedef transform::visitor  _visitor;
    typedef transform::arg0     _arg0;
    typedef transform::arg1     _arg1;
    typedef transform::arg2     _arg2;
    typedef transform::arg3     _arg3;
    typedef transform::arg4     _arg4;
    typedef transform::arg5     _arg5;
    typedef transform::arg6     _arg6;
    typedef transform::arg7     _arg7;
    typedef transform::arg8     _arg8;
    typedef transform::arg9     _arg9;
    typedef transform::arg      _arg;
    typedef transform::left     _left;
    typedef transform::right    _right;

    template<int I>
    struct _arg_c;

    using transform::_ref;

    template<typename T>
    struct is_extension;

    namespace exops
    {}

    typedef void ignore_();
    inline void ignore()
    {}

}} // namespace boost::proto

#endif