functorold.h

loki库的源代码。loki库是以模板技术和面向对象技术为基础的c++类库。

				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8, A9 p9, A10 p10, A11 p11, A12 p12,
								A13 p13, A14 p14)
				{
					return ((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8, p9, p10, p11, p12, p13, p14);
				}

		};
	};

	template <>
	struct MemFunCallWrapper<void>
	{
		template <class ParentFunctor, class pToObj, class pToMemFun>
		struct In
		{
			typedef VoidAsType R;
			typedef typename ParentFunctor::Impl Base;
			typedef typename Base::Parm1 A0;
			typedef typename Base::Parm2 A1;
			typedef typename Base::Parm3 A2;
			typedef typename Base::Parm4 A3;
			typedef typename Base::Parm5 A4;
			typedef typename Base::Parm6 A5;
			typedef typename Base::Parm7 A6;
			typedef typename Base::Parm8 A7;
			typedef typename Base::Parm9 A8;
			typedef typename Base::Parm10 A9;
			typedef typename Base::Parm11 A10;
			typedef typename Base::Parm12 A11;
			typedef typename Base::Parm13 A12;
			typedef typename Base::Parm14 A13;
			typedef typename Base::Parm15 A14;
			private:
				pToObj		pObj_;
				pToMemFun	pMemFun_;
			public:
				In(const pToObj& pObj, pToMemFun pMemFun)
					: pObj_(pObj)
					, pMemFun_(pMemFun)
				{}

				R operator() (){((*pObj_).*pMemFun_)(); return VoidAsType();}
				R operator()(A0 p0)
				{((*pObj_).*pMemFun_)(p0); return VoidAsType();}
				R operator()(A0 p0, A1 p1)
				{
					((*pObj_).*pMemFun_)(p0, p1);
					return VoidAsType();
				}


				R operator()(A0 p0, A1 p1, A2 p2)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2);
					return VoidAsType();
				}

				R operator()(A0 p0, A1 p1, A2 p2, A3 p3)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3);
					return VoidAsType();
				}

				R operator()(A0 p0, A1 p1, A2 p2, A3 p3, A4 p4)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4);
					return VoidAsType();
				}

				R operator()(A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5);
					return VoidAsType();
				}

				R operator()(A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6);
					return VoidAsType();
				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7);
					return VoidAsType();
				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8);
					return VoidAsType();
				}


				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8, A9 p9)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8, p9);
					return VoidAsType();
				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8, A9 p9, A10 p10)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8, p9, p10);
					return VoidAsType();
				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8, A9 p9, A10 p10, A11 p11)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8, p9, p10, p11);
					return VoidAsType();
				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8, A9 p9, A10 p10, A11 p11, A12 p12)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8, p9, p10, p11, p12);
					return VoidAsType();
				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8, A9 p9, A10 p10, A11 p11, A12 p12,
								A13 p13)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8, p9, p10, p11, p12, p13);
					return VoidAsType();
				}

				R operator()(	A0 p0, A1 p1, A2 p2, A3 p3, A4 p4, A5 p5, A6 p6,
								A7 p7, A8 p8, A9 p9, A10 p10, A11 p11, A12 p12,
								A13 p13, A14 p14)
				{
					((*pObj_).*pMemFun_)(p0, p1, p2, p3, p4, p5, p6,
							p7, p8, p9, p10, p11, p12, p13, p14);
					return VoidAsType();
				}

		};
	};

}

////////////////////////////////////////////////////////////////////////////////
// class template FunctorHandler
// Wraps functors and pointers to functions
////////////////////////////////////////////////////////////////////////////////
	template <class ParentFunctor, typename Fun>
	class FunctorHandler : public ParentFunctor::Impl
    {
        typedef typename ParentFunctor::Impl Base;

    public:
		typedef typename Base::ResultType ResultType;
		typedef typename Base::NewRType NewRType;
		typedef typename ParentFunctor::ThreadModel ThreadModel;
        typedef typename Base::Parm1 Parm1;
        typedef typename Base::Parm2 Parm2;
        typedef typename Base::Parm3 Parm3;
        typedef typename Base::Parm4 Parm4;
        typedef typename Base::Parm5 Parm5;
        typedef typename Base::Parm6 Parm6;
        typedef typename Base::Parm7 Parm7;
        typedef typename Base::Parm8 Parm8;
        typedef typename Base::Parm9 Parm9;
        typedef typename Base::Parm10 Parm10;
        typedef typename Base::Parm11 Parm11;
        typedef typename Base::Parm12 Parm12;
        typedef typename Base::Parm13 Parm13;
        typedef typename Base::Parm14 Parm14;
        typedef typename Base::Parm15 Parm15;
	private:
		typedef typename
		Private::FunCallWrapper<ResultType>::template In
		<ParentFunctor, Fun> CallImplType;
	public:
        FunctorHandler(const Fun& fun) : CallImpl_(fun) {}

        DEFINE_CLONE_FUNCTORIMPL(FunctorHandler)

        // operator() implementations for up to 15 arguments

        NewRType operator()()
        {
			return CallImpl_();
		}

        NewRType operator()(Parm1 p1)
        { return CallImpl_(p1);}

        NewRType operator()(Parm1 p1, Parm2 p2)
        { return CallImpl_(p1, p2); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
        { return CallImpl_(p1, p2, p3); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
        { return CallImpl_(p1, p2, p3, p4);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
        { return CallImpl_(p1, p2, p3, p4, p5);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6)
        { return CallImpl_(p1, p2, p3, p4, p5, p6);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
									p11);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
            Parm12 p12)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
									p11, p12);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
            Parm12 p12, Parm13 p13)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
									p11, p12, p13);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
            Parm12 p12, Parm13 p13, Parm14 p14)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
									p11, p12, p13, p14);}

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9, Parm10 p10, Parm11 p11,
            Parm12 p12, Parm13 p13, Parm14 p14, Parm15 p15)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10,
									p11, p12, p13, p14, p15);}

    private:
        CallImplType CallImpl_;
    };



////////////////////////////////////////////////////////////////////////////////
// class template FunctorHandler
// Wraps pointers to member functions
////////////////////////////////////////////////////////////////////////////////

    template <class ParentFunctor, typename PointerToObj,
        typename PointerToMemFn>
    class MemFunHandler : public ParentFunctor::Impl
    {
        typedef typename ParentFunctor::Impl Base;

    public:
        typedef typename Base::ResultType ResultType;
        typedef typename Base::NewRType NewRType;
		typedef typename ParentFunctor::ThreadModel ThreadModel;
		typedef typename Base::Parm1 Parm1;
        typedef typename Base::Parm2 Parm2;
        typedef typename Base::Parm3 Parm3;
        typedef typename Base::Parm4 Parm4;
        typedef typename Base::Parm5 Parm5;
        typedef typename Base::Parm6 Parm6;
        typedef typename Base::Parm7 Parm7;
        typedef typename Base::Parm8 Parm8;
        typedef typename Base::Parm9 Parm9;
        typedef typename Base::Parm10 Parm10;
        typedef typename Base::Parm11 Parm11;
        typedef typename Base::Parm12 Parm12;
        typedef typename Base::Parm13 Parm13;
        typedef typename Base::Parm14 Parm14;
        typedef typename Base::Parm15 Parm15;
	private:
		typedef typename Private::MemFunCallWrapper<ResultType>::template In
		<
			ParentFunctor,
			PointerToObj,
			PointerToMemFn
		> CallImplType;

	public:
		MemFunHandler(const PointerToObj& pObj, PointerToMemFn pMemFn)
			: CallImpl_(pObj, pMemFn)
        {}

        DEFINE_CLONE_FUNCTORIMPL(MemFunHandler)

		NewRType operator()()
        { return CallImpl_(); }

        NewRType operator()(Parm1 p1)
        { return CallImpl_(p1); }

        NewRType operator()(Parm1 p1, Parm2 p2)
        { return CallImpl_(p1, p2); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
        { return CallImpl_(p1, p2, p3); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
        { return CallImpl_(p1, p2, p3, p4); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
        { return CallImpl_(p1, p2, p3, p4, p5); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6)
        { return CallImpl_(p1, p2, p3, p4, p5, p6); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8); }

        NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
            Parm6 p6, Parm7 p7, Parm8 p8, Parm9 p9)
        { return CallImpl_(p1, p2, p3, p4, p5, p6, p7, p8, p9); }