C++ (Cpp) BOOST_PP_ENUM_TRAILING_BINARY_PARAMS Examples

Example #1

File: funop.hpp Project: SpliFF/mingwlibs

    struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION())
    {
        typedef proto::expr<
            tag::function
          , BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))<
                Expr &
                BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), M0, ~)
            >
        > type;

        static type const call(
            Expr &expr
            BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a)
        )
        {
            type that = {
                expr
                BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), M1, ~)
            };
            return that;
        }
    };

Example #2

File: funop.hpp Project: 0xDEC0DE8/mcsema

    struct BOOST_PP_CAT(funop, BOOST_PP_ITERATION())
    {
        typedef typename proto::base_expr<
            Domain
          , tag::function
          , BOOST_PP_CAT(list, BOOST_PP_INC(BOOST_PP_ITERATION()))<
                Expr &
                BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD_TYPE, ~)
            >
        >::type type;

        BOOST_FORCEINLINE
        static type const call(
            Expr &e
            BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a)
        )
        {
            type that = {
                e
                BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), BOOST_PROTO_AS_CHILD, ~)
            };
            return that;
        }
    };

Example #3

File: construct.hpp Project: imos/icfpc2015

#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES

#define BOOST_TYPE_ERASURE_FORWARD_I(z, n, data) ::std::forward<BOOST_PP_CAT(U, n)>(BOOST_PP_CAT(u, n))
#define BOOST_TYPE_ERASURE_FORWARD(n) BOOST_PP_ENUM(n, BOOST_TYPE_ERASURE_FORWARD_I, ~)

#if N > 1

    template<
        class R
        BOOST_PP_ENUM_TRAILING_PARAMS(N, class A)
        BOOST_PP_ENUM_TRAILING_PARAMS(N, class U)
    >
    const table_type& _boost_type_erasure_extract_table(
        ::boost::type_erasure::constructible<R(BOOST_PP_ENUM_PARAMS(N, A))>*
        BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, U, &u))
    {
        return *::boost::type_erasure::detail::BOOST_PP_CAT(extract_table, N)(
            (R(*)(BOOST_PP_ENUM_PARAMS(N, A)))0,
            BOOST_PP_ENUM_PARAMS(N, u));
    }

    template<BOOST_PP_ENUM_PARAMS(N, class U)>
    any(BOOST_PP_ENUM_BINARY_PARAMS(N, U, &&u))
      : table(
            _boost_type_erasure_extract_table(
                false? this->_boost_type_erasure_deduce_constructor(BOOST_TYPE_ERASURE_FORWARD(N)) : 0
                BOOST_PP_ENUM_TRAILING_PARAMS(N, u)
            )
        ),
        data(::boost::type_erasure::call(

Example #4

File: inlined_mem_fun_include.hpp Project: himura/p-stade

// http://www.boost.org/LICENSE_1_0.txt)


#if !defined(cv_qualifier)
    #error Please define cv_qualifier.
#endif


    template<class R, class T BOOST_PP_ENUM_TRAILING_PARAMS(n, class A), R (T::*ptr)(fparams) cv_qualifier>
    struct inlined<R (T::*)(fparams) cv_qualifier, ptr>
    {
        typedef inlined type;

        typedef R result_type;

        template<class U>
        result_type operator()(U &u BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(n, A, a)) const
        {
            return details::free_call<R, T>(ptr, u BOOST_PP_ENUM_TRAILING_PARAMS(n, a));
        }

        template<class U>
        result_type operator()(U const &u BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(n, A, a)) const
        {
            return details::free_call<R, T>(ptr, u BOOST_PP_ENUM_TRAILING_PARAMS(n, a));
        }
    };


#undef  cv_qualifier