📄 functorold.h
字号:
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 Functor
// A generalized functor implementation with value semantics
////////////////////////////////////////////////////////////////////////////////
struct Disambiguate
{
Disambiguate() {}
};
template<typename R, class TList = NullType,
class ThreadingModel = DEFAULT_THREADING>
class Functor
{
public:
// Handy type definitions for the body type
typedef FunctorImpl<R, TList, ThreadingModel> Impl;
typedef R ResultType;
typedef TList ParmList;
typedef ThreadingModel ThreadModel;
typedef typename Select
< Private::IsVoid<R>::value != 0,
Private::VoidAsType, R
>::Result NewRType;
typedef typename Impl::Parm1 Parm1;
typedef typename Impl::Parm2 Parm2;
typedef typename Impl::Parm3 Parm3;
typedef typename Impl::Parm4 Parm4;
typedef typename Impl::Parm5 Parm5;
typedef typename Impl::Parm6 Parm6;
typedef typename Impl::Parm7 Parm7;
typedef typename Impl::Parm8 Parm8;
typedef typename Impl::Parm9 Parm9;
typedef typename Impl::Parm10 Parm10;
typedef typename Impl::Parm11 Parm11;
typedef typename Impl::Parm12 Parm12;
typedef typename Impl::Parm13 Parm13;
typedef typename Impl::Parm14 Parm14;
typedef typename Impl::Parm15 Parm15;
public:
// Member functions
Functor() : spImpl_()
{}
// we can't use loki's original approach with VC 6 because
// this compiler will not recognize the copy-ctor
// if a template-ctor is present.
//template <typename Fun>
//Functor(Fun fun)
//: spImpl_(new FunctorHandler<Functor, Fun>(fun))
//{}
template <class Fun>
Functor(Fun fun, Loki::Disambiguate)
: spImpl_(new FunctorHandler<Functor, Fun>(fun))
{}
Functor(const Functor& rhs) : spImpl_(Impl::Clone(rhs.spImpl_.get()))
{}
// Ctor for user defined impl-classes
Functor(std::auto_ptr<Impl> spImpl) : spImpl_(spImpl)
{}
// ctors for functions with up to 15 arguments.
template <class Ret>
Functor(Ret (*p)()) : spImpl_(new FunctorHandler<Functor, Ret(*)()>(p))
{}
template <class Ret, class A0>
Functor(Ret (*p)(A0))
: spImpl_(new FunctorHandler<Functor, Ret(*)(A0)>(p))
{}
template <class Ret, class A0, class A1>
Functor(Ret (*p)(A0, A1))
: spImpl_(new FunctorHandler<Functor, Ret(*)(A0, A1)>(p))
{}
template <class Ret, class A0, class A1, class A2>
Functor(Ret (*p)(A0, A1, A2))
: spImpl_(new FunctorHandler<Functor, Ret(*)(A0, A1, A2)>(p))
{}
template <class Ret, class A0, class A1, class A2, class A3>
Functor(Ret (*p)(A0, A1, A2, A3))
: spImpl_(new FunctorHandler<Functor, Ret(*)(A0, A1, A2, A3)>(p))
{}
template <class Ret, class A0, class A1, class A2, class A3, class A4>
Functor(Ret (*p)(A0, A1, A2, A3, A4))
: spImpl_(new FunctorHandler<Functor, Ret(*)(A0, A1, A2, A3, A4)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7, A8))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7, A8)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8, class A9
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8, class A9, class A10
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8, class A9, class A10,
class A11
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8, class A9, class A10,
class A11, class A12
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8, class A9, class A10,
class A11, class A12, class A13
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13)>(p))
{}
template
<
class Ret, class A0, class A1, class A2, class A3, class A4,
class A5, class A6, class A7, class A8, class A9, class A10,
class A11, class A12, class A13, class A14
>
Functor(Ret (*p)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14))
: spImpl_(new FunctorHandler<Functor,
Ret(*)(A0, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14)>(p))
{}
// alternative way to create a functor using a function pointer.
// The two dummy parameters are needed to disambiguate this ctor
// from the ctor for creating functors with an object and a pointer
// to a member-function.
// Use the macro FUNCTION_POINTER to create objects, e.g.
// Functor<int, TYPELIST_2(int, int)> obj(pFunc, FUNCTION_POINTER);
/*
template <class Fun>
Functor(Fun fun, int* pDummy1, int* pDummy2)
: spImpl_(new FunctorHandler<Functor, Fun>(fun))
{}
*/
template <class PtrObj, typename MemFn>
Functor(const PtrObj& p, MemFn memFn)
: spImpl_(new MemFunHandler<Functor, PtrObj, MemFn>(p, memFn))
{}
Functor& operator=(const Functor& rhs)
{
if (this == &rhs)
return *this;
// the auto_ptr provided by the MSVC 6.0 does not have
// a reset-function.
Functor copy(rhs);
delete spImpl_.release();
spImpl_ = copy.spImpl_;
return *this;
}
NewRType operator()()
{ return (*spImpl_)(); }
NewRType operator()(Parm1 p1)
{ return (*spImpl_)(p1); }
NewRType operator()(Parm1 p1, Parm2 p2)
{ return (*spImpl_)(p1, p2); }
NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3)
{ return (*spImpl_)(p1, p2, p3); }
NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4)
{ return (*spImpl_)(p1, p2, p3, p4); }
NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5)
{ return (*spImpl_)(p1, p2, p3, p4, p5); }
NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
Parm6 p6)
{ return (*spImpl_)(p1, p2, p3, p4, p5, p6); }
NewRType operator()(Parm1 p1, Parm2 p2, Parm3 p3, Parm4 p4, Parm5 p5,
Parm6 p6, Parm7 p7)
{ return (*spImpl_)(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 (*spImpl_)(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 (*spImpl_)(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 (*spImpl_)(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 (*spImpl_)(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 (*spImpl_)(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 (*spImpl_)(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 (*spImpl_)(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 (*spImpl_)(p1, p2, p3, p⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -