binders.hpp

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

>
struct member_function_ptr_action<RT, ClassT,
    A, B, C, D, E, F, nil_t, nil_t, nil_t,
#if PHOENIX_LIMIT > 9
    nil_t, nil_t, nil_t,
#if PHOENIX_LIMIT > 12
    nil_t, nil_t, nil_t,
#endif
#endif
    nil_t   //  Unused
> {

    typedef RT result_type;
    typedef RT(ClassT::*mf)(A, B, C, D, E, F);
    typedef RT(ClassT::*cmf)(A, B, C, D, E, F) const;
    typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
        mem_func_ptr_t;

    template <typename CT,
        typename A_, typename B_, typename C_, typename D_,
        typename E_, typename F_
    >
    struct result { typedef result_type type; };

    member_function_ptr_action(mem_func_ptr_t fptr_)
    :   fptr(fptr_) {}

    template <typename CT>
    result_type operator()(CT& obj,
        A a, B b, C c, D d, E e, F f
    ) const
    { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f); }

    mem_func_ptr_t fptr;
};

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F
>
inline member_function_ptr<RT, ClassT, A, B, C, D, E, F>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F))
{
    return member_function_ptr<
        RT, ClassT, A, B, C, D, E, F>(fptr);
}

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F
>
inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F) const)
{
    return member_function_ptr<
        RT, ClassT const, A, B, C, D, E, F>(fptr);
}

///////////////////////////////////////////////////////////////////////////////
//
//  Member function pointer binder (specialization for 7 args)
//
///////////////////////////////////////////////////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G
>
struct member_function_ptr_action<RT, ClassT,
    A, B, C, D, E, F, G, nil_t, nil_t,
#if PHOENIX_LIMIT > 9
    nil_t, nil_t, nil_t,
#if PHOENIX_LIMIT > 12
    nil_t, nil_t, nil_t,
#endif
#endif
    nil_t   //  Unused
> {

    typedef RT result_type;
    typedef RT(ClassT::*mf)(A, B, C, D, E, F, G);
    typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G) const;
    typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
        mem_func_ptr_t;

    template <typename CT,
        typename A_, typename B_, typename C_, typename D_,
        typename E_, typename F_, typename G_
    >
    struct result { typedef result_type type; };

    member_function_ptr_action(mem_func_ptr_t fptr_)
    :   fptr(fptr_) {}

    template <typename CT>
    result_type operator()(CT& obj,
        A a, B b, C c, D d, E e, F f, G g
    ) const
    { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g); }

    mem_func_ptr_t fptr;
};

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G
>
inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G))
{
    return member_function_ptr<
        RT, ClassT, A, B, C, D, E, F, G>(fptr);
}

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G
>
inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G) const)
{
    return member_function_ptr<
        RT, ClassT const, A, B, C, D, E, F, G>(fptr);
}

///////////////////////////////////////////////////////////////////////////////
//
//  Member function pointer binder (specialization for 8 args)
//
///////////////////////////////////////////////////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H
>
struct member_function_ptr_action<RT, ClassT,
    A, B, C, D, E, F, G, H, nil_t,
#if PHOENIX_LIMIT > 9
    nil_t, nil_t, nil_t,
#if PHOENIX_LIMIT > 12
    nil_t, nil_t, nil_t,
#endif
#endif
    nil_t   //  Unused
> {

    typedef RT result_type;
    typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H);
    typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H) const;
    typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
        mem_func_ptr_t;

    template <typename CT,
        typename A_, typename B_, typename C_, typename D_,
        typename E_, typename F_, typename G_, typename H_
    >
    struct result { typedef result_type type; };

    member_function_ptr_action(mem_func_ptr_t fptr_)
    :   fptr(fptr_) {}

    template <typename CT>
    result_type operator()(CT& obj,
        A a, B b, C c, D d, E e, F f, G g, H h
    ) const
    { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g, h); }

    mem_func_ptr_t fptr;
};

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H
>
inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H))
{
    return member_function_ptr<
        RT, ClassT, A, B, C, D, E, F, G, H>(fptr);
}

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H
>
inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H) const)
{
    return member_function_ptr<
        RT, ClassT const, A, B, C, D, E, F, G, H>(fptr);
}

#if PHOENIX_LIMIT > 9
///////////////////////////////////////////////////////////////////////////////
//
//  Member function pointer binder (specialization for 9 args)
//
///////////////////////////////////////////////////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I
>
struct member_function_ptr_action<RT, ClassT,
    A, B, C, D, E, F, G, H, I, nil_t, nil_t, nil_t,
#if PHOENIX_LIMIT > 12
    nil_t, nil_t, nil_t,
#endif
    nil_t   //  Unused
> {

    typedef RT result_type;
    typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I);
    typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I) const;
    typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
        mem_func_ptr_t;

    template <typename CT,
        typename A_, typename B_, typename C_, typename D_,
        typename E_, typename F_, typename G_, typename H_, typename I_
    >
    struct result { typedef result_type type; };

    member_function_ptr_action(mem_func_ptr_t fptr_)
    :   fptr(fptr_) {}

    template <typename CT>
    result_type operator()(CT& obj,
        A a, B b, C c, D d, E e, F f, G g, H h, I i
    ) const
    { return (impl::as_ptr<CT>::get(obj)->*fptr)(a, b, c, d, e, f, g, h, i); }

    mem_func_ptr_t fptr;
};

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I
>
inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I))
{
    return member_function_ptr<
        RT, ClassT, A, B, C, D, E, F, G, H, I>(fptr);
}

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I
>
inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I) const)
{
    return member_function_ptr<
        RT, ClassT const, A, B, C, D, E, F, G, H, I>(fptr);
}

///////////////////////////////////////////////////////////////////////////////
//
//  Member function pointer binder (specialization for 10 args)
//
///////////////////////////////////////////////////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J
>
struct member_function_ptr_action<RT, ClassT,
    A, B, C, D, E, F, G, H, I, J, nil_t, nil_t,
#if PHOENIX_LIMIT > 12
    nil_t, nil_t, nil_t,
#endif
    nil_t   //  Unused
> {

    typedef RT result_type;
    typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J);
    typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J) const;
    typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
        mem_func_ptr_t;

    template <typename CT,
        typename A_, typename B_, typename C_, typename D_,
        typename E_, typename F_, typename G_, typename H_, typename I_,
        typename J_
    >
    struct result { typedef result_type type; };

    member_function_ptr_action(mem_func_ptr_t fptr_)
    :   fptr(fptr_) {}

    template <typename CT>
    result_type operator()(CT& obj,
        A a, B b, C c, D d, E e, F f, G g, H h, I i, J j
    ) const
    {
        return (impl::as_ptr<CT>::get(obj)->*fptr)
            (a, b, c, d, e, f, g, h, i, j);
    }

    mem_func_ptr_t fptr;
};

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J
>
inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J))
{
    return member_function_ptr<
        RT, ClassT, A, B, C, D, E, F, G, H, I, J>(fptr);
}

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J
>
inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J) const)
{
    return member_function_ptr<
        RT, ClassT const, A, B, C, D, E, F, G, H, I, J>(fptr);
}

///////////////////////////////////////////////////////////////////////////////
//
//  Member function pointer binder (specialization for 11 args)
//
///////////////////////////////////////////////////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J, typename K
>
struct member_function_ptr_action<RT, ClassT,
    A, B, C, D, E, F, G, H, I, J, K, nil_t,
#if PHOENIX_LIMIT > 12
    nil_t, nil_t, nil_t,
#endif
    nil_t   //  Unused
> {

    typedef RT result_type;
    typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K);
    typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K) const;
    typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
        mem_func_ptr_t;

    template <typename CT,
        typename A_, typename B_, typename C_, typename D_,
        typename E_, typename F_, typename G_, typename H_, typename I_,
        typename J_, typename K_
    >
    struct result { typedef result_type type; };

    member_function_ptr_action(mem_func_ptr_t fptr_)
    :   fptr(fptr_) {}

    template <typename CT>
    result_type operator()(CT& obj,
        A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k
    ) const
    {
        return (impl::as_ptr<CT>::get(obj)->*fptr)
            (a, b, c, d, e, f, g, h, i, j, k);
    }

    mem_func_ptr_t fptr;
};

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J, typename K
>
inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K))
{
    return member_function_ptr<
        RT, ClassT, A, B, C, D, E, F, G, H, I, J, K>(fptr);
}

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J, typename K
>
inline member_function_ptr<RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K) const)
{
    return member_function_ptr<
        RT, ClassT const, A, B, C, D, E, F, G, H, I, J, K>(fptr);
}

#if PHOENIX_LIMIT > 12
///////////////////////////////////////////////////////////////////////////////
//
//  Member function pointer binder (specialization for 12 args)
//
///////////////////////////////////////////////////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J, typename K, typename L
>
struct member_function_ptr_action<RT, ClassT,
    A, B, C, D, E, F, G, H, I, J, K, L, nil_t, nil_t, nil_t, nil_t> {

    typedef RT result_type;
    typedef RT(ClassT::*mf)(A, B, C, D, E, F, G, H, I, J, K, L);
    typedef RT(ClassT::*cmf)(A, B, C, D, E, F, G, H, I, J, K, L) const;
    typedef typename boost::mpl::if_<boost::is_const<ClassT>, cmf, mf>::type
        mem_func_ptr_t;

    template <typename CT,
        typename A_, typename B_, typename C_, typename D_,
        typename E_, typename F_, typename G_, typename H_, typename I_,
        typename J_, typename K_, typename L_
    >
    struct result { typedef result_type type; };

    member_function_ptr_action(mem_func_ptr_t fptr_)
    :   fptr(fptr_) {}

    template <typename CT>
    result_type operator()(CT& obj,
        A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l
    ) const
    {
        return (impl::as_ptr<CT>::get(obj)->*fptr)
            (a, b, c, d, e, f, g, h, i, j, k, l);
    }

    mem_func_ptr_t fptr;
};

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J, typename K, typename L
>
inline member_function_ptr<RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>
bind(RT(ClassT::*fptr)(A, B, C, D, E, F, G, H, I, J, K, L))
{
    return member_function_ptr<
        RT, ClassT, A, B, C, D, E, F, G, H, I, J, K, L>(fptr);
}

//////////////////////////////////
template <typename RT, typename ClassT,
    typename A, typename B, typename C, typename D,
    typename E, typename F, typename G, typename H, typename I,
    typename J, typename