异步线程任务封装
来源：互联网 发布：树莓派 linux游戏 编辑：程序博客网 时间：2024/05/16 03:28
异步线程任务封装可以参考Chrome中Callback和tuple实现。
Callback.h
#ifndef __callback_h__#define __callback_h__#pragma once#include "base/tuple.h"#include "raw_scoped_refptr_mismatch_checker.h"// Callback跟Task很像, 但没有参数限制, 实质上是面向对象的函数指针.//// Callbacks被设计和Tuples共同工作. 有一系列的辅助函数和类用于对使用者隐藏// Tuple的细节. 用户代码只需要和CallbackRunner基类打交道, CallbackRunner只// 有Run方法, 通过New*函数创建. 这样用户不必关心哪个类实现了回调, 只需要知// 道参数个数以及类型.//// 这些实现是通过CallbackImpl完成的, CallbackImpl派生自CallbackStorage, 具体// 的存储类型对用户透明, 用户只需要调用即可.//// 注意callbacks目前不能取消或者放弃自己的操作, 现在是在上层进行处理的.// callback中的指针在调用结束前都必须是有效的.//// 类似Task, 一旦回调执行结束, 回调执行者负责删除回调指针.//// 客户端用法示例:// void Object::DoStuff(int, string);// Callback2<int, string>::Type* callback =// NewCallback(obj, &Object::DoStuff);// callback->Run(5, string("hello"));// delete callback;// 或者直接使用元组:// CallbackRunner<Tuple2<int, string> >* callback =// NewCallback(obj, &Object::DoStuff);// callback->RunWithParams(MakeTuple(5, string("hello")));//// 有一个不带参数有返回值的版本. 示例:// int Object::GetNextInt();// CallbackWithReturnValue<int>::Type* callback =// NewCallbackWithReturnValue(obj, &Object::GetNextInt);// int next_int = callback->Run();// delete callback;// 所有Callbacks的基类, 存储对象方法指针.template<class T, typename Method>class CallbackStorage{public: CallbackStorage(T* obj, Method meth) : obj_(obj), meth_(meth) {}protected: T* obj_; Method meth_;};// Interface that is exposed to the consumer, that does the actual calling// of the method.template<typename Params>class CallbackRunner{public: typedef Params TupleType; virtual ~CallbackRunner() {} virtual void RunWithParams(const Params& params) = 0; // Convenience functions so callers don't have to deal with Tuples. inline void Run() { RunWithParams(Tuple0()); } template<typename Arg1> inline void Run(const Arg1& a) { RunWithParams(Params(a)); } template<typename Arg1, typename Arg2> inline void Run(const Arg1& a, const Arg2& b) { RunWithParams(Params(a, b)); } template<typename Arg1, typename Arg2, typename Arg3> inline void Run(const Arg1& a, const Arg2& b, const Arg3& c) { RunWithParams(Params(a, b, c)); } template<typename Arg1, typename Arg2, typename Arg3, typename Arg4> inline void Run(const Arg1& a, const Arg2& b, const Arg3& c, const Arg4& d) { RunWithParams(Params(a, b, c, d)); } template<typename Arg1, typename Arg2, typename Arg3, typename Arg4, typename Arg5> inline void Run(const Arg1& a, const Arg2& b, const Arg3& c, const Arg4& d, const Arg5& e) { RunWithParams(Params(a, b, c, d, e)); }};template<class T, typename Method, typename Params>class CallbackImpl : public CallbackStorage<T, Method>, public CallbackRunner<Params>{public: CallbackImpl(T* obj, Method meth) : CallbackStorage<T, Method>(obj, meth) {} virtual void RunWithParams(const Params& params) { // use "this->" to force C++ to look inside our templatized base class; see // Effective C++, 3rd Ed, item 43, p210 for details. DispatchToMethod(this->obj_, this->meth_, params); }};// 0-arg implementationstruct Callback0{ typedef CallbackRunner<Tuple0> Type;};template<class T>typename Callback0::Type* NewCallback(T* object, void (T::*method)()){ return new CallbackImpl<T, void (T::*)(), Tuple0 >(object, method);}// 1-arg implementationtemplate<typename Arg1>struct Callback1{ typedef CallbackRunner<Tuple1<Arg1> > Type;};template<class T, typename Arg1>typename Callback1<Arg1>::Type* NewCallback(T* object, void (T::*method)(Arg1)){ return new CallbackImpl<T, void (T::*)(Arg1), Tuple1<Arg1> >(object, method);}// 2-arg implementationtemplate<typename Arg1, typename Arg2>struct Callback2{ typedef CallbackRunner<Tuple2<Arg1, Arg2> > Type;};template<class T, typename Arg1, typename Arg2>typename Callback2<Arg1, Arg2>::Type* NewCallback( T* object, void (T::*method)(Arg1, Arg2)){ return new CallbackImpl<T, void (T::*)(Arg1, Arg2), Tuple2<Arg1, Arg2> >(object, method);}// 3-arg implementationtemplate<typename Arg1, typename Arg2, typename Arg3>struct Callback3{ typedef CallbackRunner<Tuple3<Arg1, Arg2, Arg3> > Type;};template<class T, typename Arg1, typename Arg2, typename Arg3>typename Callback3<Arg1, Arg2, Arg3>::Type* NewCallback( T* object, void (T::*method)(Arg1, Arg2, Arg3)){ return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3), Tuple3<Arg1, Arg2, Arg3> >(object, method);}// 4-arg implementationtemplate<typename Arg1, typename Arg2, typename Arg3, typename Arg4>struct Callback4{ typedef CallbackRunner<Tuple4<Arg1, Arg2, Arg3, Arg4> > Type;};template<class T, typename Arg1, typename Arg2, typename Arg3, typename Arg4>typename Callback4<Arg1, Arg2, Arg3, Arg4>::Type* NewCallback( T* object, void (T::*method)(Arg1, Arg2, Arg3, Arg4)){ return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3, Arg4), Tuple4<Arg1, Arg2, Arg3, Arg4> >(object, method);}// 5-arg implementationtemplate<typename Arg1, typename Arg2, typename Arg3,typename Arg4, typename Arg5>struct Callback5{ typedef CallbackRunner<Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> > Type;};template<class T, typename Arg1, typename Arg2,typename Arg3, typename Arg4, typename Arg5>typename Callback5<Arg1, Arg2, Arg3, Arg4, Arg5>::Type* NewCallback( T* object, void (T::*method)(Arg1, Arg2, Arg3, Arg4, Arg5)){ return new CallbackImpl<T, void (T::*)(Arg1, Arg2, Arg3, Arg4, Arg5), Tuple5<Arg1, Arg2, Arg3, Arg4, Arg5> >(object, method);}// An UnboundMethod is a wrapper for a method where the actual object is// provided at Run dispatch time.template<class T, class Method, class Params>class UnboundMethod{public: UnboundMethod(Method m, const Params& p) : m_(m), p_(p) { COMPILE_ASSERT((MethodUsesScopedRefptrCorrectly<Method, Params>::value), badunboundmethodparams); } void Run(T* obj) const { DispatchToMethod(obj, m_, p_); }private: Method m_; Params p_;};// 无参数带返回值版本.template<typename ReturnValue>struct CallbackWithReturnValue{ class Type { public: virtual ~Type() {} virtual ReturnValue Run() = 0; };};template<class T, typename Method, typename ReturnValue>class CallbackWithReturnValueImpl : public CallbackStorage<T, Method>, public CallbackWithReturnValue<ReturnValue>::Type{public: CallbackWithReturnValueImpl(T* obj, Method meth) : CallbackStorage<T, Method>(obj, meth) {} virtual ReturnValue Run() { return (this->obj_->*(this->meth_))(); }protected: virtual ~CallbackWithReturnValueImpl() {}};template<class T, typename ReturnValue>typename CallbackWithReturnValue<ReturnValue>::Type*NewCallbackWithReturnValue(T* object, ReturnValue (T::*method)()){ return new CallbackWithReturnValueImpl<T, ReturnValue (T::*)(), ReturnValue>(object, method);}#endif //__callback_h__chrome自己实现tuple
#ifndef __tuple_h__#define __tuple_h__#pragma once// 元组(Tuple)是一种概念上与std::pair类似的通用模板容器.// Tuple0到Tuple6对应容器中元素个数. 带有0-6个参数的MakeTuple()函数能够方便// 的构造对应的元组对象. DispatchToMethod和DispatchToFunction带有函数指针或// 者对象实例和成员函数指针, 解包元组为参数进行函数调用.//// 元组的元素通过值拷贝存储.//// 用法示例:// // These two methods of creating a Tuple are identical.// Tuple2<int, const char*> tuple_a(1, "wee");// Tuple2<int, const char*> tuple_b = MakeTuple(1, "wee");//// void SomeFunc(int a, const char* b) {}// DispatchToFunction(&SomeFunc, tuple_a); // SomeFunc(1, "wee")// DispatchToFunction(// &SomeFunc, MakeTuple(10, "foo")); // SomeFunc(10, "foo")//// struct { void SomeMeth(int a, int b, int c) {} } foo;// DispatchToMethod(&foo, &Foo::SomeMeth, MakeTuple(1, 2, 3));// //foo->SomeMeth(1, 2, 3);// Traits ----------------------------------------------------------------------//// A simple traits class for tuple arguments.//// ValueType: the bare, nonref version of a type (same as the type for nonrefs).// RefType: the ref version of a type (same as the type for refs).// ParamType: what type to pass to functions (refs should not be constified).template<class P>struct TupleTraits{ typedef P ValueType; typedef P& RefType; typedef const P& ParamType;};template<class P>struct TupleTraits<P&>{ typedef P ValueType; typedef P& RefType; typedef P& ParamType;};template<class P>struct TupleTypes {};// Tuple -----------------------------------------------------------------------//// This set of classes is useful for bundling 0 or more heterogeneous data types// into a single variable. The advantage of this is that it greatly simplifies// function objects that need to take an arbitrary number of parameters; see// RunnableMethod and IPC::MessageWithTuple.//// Tuple0 is supplied to act as a 'void' type. It can be used, for example,// when dispatching to a function that accepts no arguments (see the// Dispatchers below).// Tuple1<A> is rarely useful. One such use is when A is non-const ref that you// want filled by the dispatchee, and the tuple is merely a container for that// output (a "tier"). See MakeRefTuple and its usages.struct Tuple0{ typedef Tuple0 ValueTuple; typedef Tuple0 RefTuple; typedef Tuple0 ParamTuple;};template<class A>struct Tuple1{public: typedef A TypeA; Tuple1() {} explicit Tuple1(typename TupleTraits<A>::ParamType a) : a(a) {} A a;};template<class A, class B>struct Tuple2{public: typedef A TypeA; typedef B TypeB; Tuple2() {} Tuple2(typename TupleTraits<A>::ParamType a, typename TupleTraits<B>::ParamType b) : a(a), b(b) {} A a; B b;};template<class A, class B, class C>struct Tuple3{public: typedef A TypeA; typedef B TypeB; typedef C TypeC; Tuple3() {} Tuple3(typename TupleTraits<A>::ParamType a, typename TupleTraits<B>::ParamType b, typename TupleTraits<C>::ParamType c) : a(a), b(b), c(c){} A a; B b; C c;};template<class A, class B, class C, class D>struct Tuple4{public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; Tuple4() {} Tuple4(typename TupleTraits<A>::ParamType a, typename TupleTraits<B>::ParamType b, typename TupleTraits<C>::ParamType c, typename TupleTraits<D>::ParamType d) : a(a), b(b), c(c), d(d) {} A a; B b; C c; D d;};template<class A, class B, class C, class D, class E>struct Tuple5{public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; Tuple5() {} Tuple5(typename TupleTraits<A>::ParamType a, typename TupleTraits<B>::ParamType b, typename TupleTraits<C>::ParamType c, typename TupleTraits<D>::ParamType d, typename TupleTraits<E>::ParamType e) : a(a), b(b), c(c), d(d), e(e) {} A a; B b; C c; D d; E e;};template<class A, class B, class C, class D, class E, class F>struct Tuple6{public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; typedef F TypeF; Tuple6() {} Tuple6(typename TupleTraits<A>::ParamType a, typename TupleTraits<B>::ParamType b, typename TupleTraits<C>::ParamType c, typename TupleTraits<D>::ParamType d, typename TupleTraits<E>::ParamType e, typename TupleTraits<F>::ParamType f) : a(a), b(b), c(c), d(d), e(e), f(f) {} A a; B b; C c; D d; E e; F f;};template<class A, class B, class C, class D, class E, class F, class G>struct Tuple7{public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; typedef F TypeF; typedef G TypeG; Tuple7() {} Tuple7(typename TupleTraits<A>::ParamType a, typename TupleTraits<B>::ParamType b, typename TupleTraits<C>::ParamType c, typename TupleTraits<D>::ParamType d, typename TupleTraits<E>::ParamType e, typename TupleTraits<F>::ParamType f, typename TupleTraits<G>::ParamType g) : a(a), b(b), c(c), d(d), e(e), f(f), g(g) {} A a; B b; C c; D d; E e; F f; G g;};template<class A, class B, class C, class D, class E, class F, class G,class H>struct Tuple8{public: typedef A TypeA; typedef B TypeB; typedef C TypeC; typedef D TypeD; typedef E TypeE; typedef F TypeF; typedef G TypeG; typedef H TypeH; Tuple8() {} Tuple8(typename TupleTraits<A>::ParamType a, typename TupleTraits<B>::ParamType b, typename TupleTraits<C>::ParamType c, typename TupleTraits<D>::ParamType d, typename TupleTraits<E>::ParamType e, typename TupleTraits<F>::ParamType f, typename TupleTraits<G>::ParamType g, typename TupleTraits<H>::ParamType h) : a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h) {} A a; B b; C c; D d; E e; F f; G g; H h;};// Tuple types ----------------------------------------------------------------//// Allows for selection of ValueTuple/RefTuple/ParamTuple without needing the// definitions of class types the tuple takes as parameters.template<>struct TupleTypes< Tuple0 >{ typedef Tuple0 ValueTuple; typedef Tuple0 RefTuple; typedef Tuple0 ParamTuple;};template<class A>struct TupleTypes< Tuple1<A> >{ typedef Tuple1<typename TupleTraits<A>::ValueType> ValueTuple; typedef Tuple1<typename TupleTraits<A>::RefType> RefTuple; typedef Tuple1<typename TupleTraits<A>::ParamType> ParamTuple;};template<class A, class B>struct TupleTypes< Tuple2<A, B> >{ typedef Tuple2<typename TupleTraits<A>::ValueType, typename TupleTraits<B>::ValueType> ValueTuple; typedef Tuple2<typename TupleTraits<A>::RefType, typename TupleTraits<B>::RefType> RefTuple; typedef Tuple2<typename TupleTraits<A>::ParamType, typename TupleTraits<B>::ParamType> ParamTuple;};template<class A, class B, class C>struct TupleTypes< Tuple3<A, B, C> >{ typedef Tuple3<typename TupleTraits<A>::ValueType, typename TupleTraits<B>::ValueType, typename TupleTraits<C>::ValueType> ValueTuple; typedef Tuple3<typename TupleTraits<A>::RefType, typename TupleTraits<B>::RefType, typename TupleTraits<C>::RefType> RefTuple; typedef Tuple3<typename TupleTraits<A>::ParamType, typename TupleTraits<B>::ParamType, typename TupleTraits<C>::ParamType> ParamTuple;};template<class A, class B, class C, class D>struct TupleTypes< Tuple4<A, B, C, D> >{ typedef Tuple4<typename TupleTraits<A>::ValueType, typename TupleTraits<B>::ValueType, typename TupleTraits<C>::ValueType, typename TupleTraits<D>::ValueType> ValueTuple; typedef Tuple4<typename TupleTraits<A>::RefType, typename TupleTraits<B>::RefType, typename TupleTraits<C>::RefType, typename TupleTraits<D>::RefType> RefTuple; typedef Tuple4<typename TupleTraits<A>::ParamType, typename TupleTraits<B>::ParamType, typename TupleTraits<C>::ParamType, typename TupleTraits<D>::ParamType> ParamTuple;};template<class A, class B, class C, class D, class E>struct TupleTypes< Tuple5<A, B, C, D, E> >{ typedef Tuple5<typename TupleTraits<A>::ValueType, typename TupleTraits<B>::ValueType, typename TupleTraits<C>::ValueType, typename TupleTraits<D>::ValueType, typename TupleTraits<E>::ValueType> ValueTuple; typedef Tuple5<typename TupleTraits<A>::RefType, typename TupleTraits<B>::RefType, typename TupleTraits<C>::RefType, typename TupleTraits<D>::RefType, typename TupleTraits<E>::RefType> RefTuple; typedef Tuple5<typename TupleTraits<A>::ParamType, typename TupleTraits<B>::ParamType, typename TupleTraits<C>::ParamType, typename TupleTraits<D>::ParamType, typename TupleTraits<E>::ParamType> ParamTuple;};template<class A, class B, class C, class D, class E, class F>struct TupleTypes< Tuple6<A, B, C, D, E, F> >{ typedef Tuple6<typename TupleTraits<A>::ValueType, typename TupleTraits<B>::ValueType, typename TupleTraits<C>::ValueType, typename TupleTraits<D>::ValueType, typename TupleTraits<E>::ValueType, typename TupleTraits<F>::ValueType> ValueTuple; typedef Tuple6<typename TupleTraits<A>::RefType, typename TupleTraits<B>::RefType, typename TupleTraits<C>::RefType, typename TupleTraits<D>::RefType, typename TupleTraits<E>::RefType, typename TupleTraits<F>::RefType> RefTuple; typedef Tuple6<typename TupleTraits<A>::ParamType, typename TupleTraits<B>::ParamType, typename TupleTraits<C>::ParamType, typename TupleTraits<D>::ParamType, typename TupleTraits<E>::ParamType, typename TupleTraits<F>::ParamType> ParamTuple;};template<class A, class B, class C, class D, class E, class F, class G>struct TupleTypes< Tuple7<A, B, C, D, E, F, G> >{ typedef Tuple7<typename TupleTraits<A>::ValueType, typename TupleTraits<B>::ValueType, typename TupleTraits<C>::ValueType, typename TupleTraits<D>::ValueType, typename TupleTraits<E>::ValueType, typename TupleTraits<F>::ValueType, typename TupleTraits<G>::ValueType> ValueTuple; typedef Tuple7<typename TupleTraits<A>::RefType, typename TupleTraits<B>::RefType, typename TupleTraits<C>::RefType, typename TupleTraits<D>::RefType, typename TupleTraits<E>::RefType, typename TupleTraits<F>::RefType, typename TupleTraits<G>::RefType> RefTuple; typedef Tuple7<typename TupleTraits<A>::ParamType, typename TupleTraits<B>::ParamType, typename TupleTraits<C>::ParamType, typename TupleTraits<D>::ParamType, typename TupleTraits<E>::ParamType, typename TupleTraits<F>::ParamType, typename TupleTraits<G>::ParamType> ParamTuple;};template<class A, class B, class C, class D, class E, class F, class G,class H>struct TupleTypes< Tuple8<A, B, C, D, E, F, G, H> >{ typedef Tuple8<typename TupleTraits<A>::ValueType, typename TupleTraits<B>::ValueType, typename TupleTraits<C>::ValueType, typename TupleTraits<D>::ValueType, typename TupleTraits<E>::ValueType, typename TupleTraits<F>::ValueType, typename TupleTraits<G>::ValueType, typename TupleTraits<H>::ValueType> ValueTuple; typedef Tuple8<typename TupleTraits<A>::RefType, typename TupleTraits<B>::RefType, typename TupleTraits<C>::RefType, typename TupleTraits<D>::RefType, typename TupleTraits<E>::RefType, typename TupleTraits<F>::RefType, typename TupleTraits<G>::RefType, typename TupleTraits<H>::RefType> RefTuple; typedef Tuple8<typename TupleTraits<A>::ParamType, typename TupleTraits<B>::ParamType, typename TupleTraits<C>::ParamType, typename TupleTraits<D>::ParamType, typename TupleTraits<E>::ParamType, typename TupleTraits<F>::ParamType, typename TupleTraits<G>::ParamType, typename TupleTraits<H>::ParamType> ParamTuple;};// Tuple creators -------------------------------------------------------------//// Helper functions for constructing tuples while inferring the template// argument types.inline Tuple0 MakeTuple(){ return Tuple0();}template<class A>inline Tuple1<A> MakeTuple(const A& a){ return Tuple1<A>(a);}template<class A, class B>inline Tuple2<A, B> MakeTuple(const A& a, const B& b){ return Tuple2<A, B>(a, b);}template<class A, class B, class C>inline Tuple3<A, B, C> MakeTuple(const A& a, const B& b, const C& c){ return Tuple3<A, B, C>(a, b, c);}template<class A, class B, class C, class D>inline Tuple4<A, B, C, D> MakeTuple(const A& a, const B& b, const C& c, const D& d){ return Tuple4<A, B, C, D>(a, b, c, d);}template<class A, class B, class C, class D, class E>inline Tuple5<A, B, C, D, E> MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e){ return Tuple5<A, B, C, D, E>(a, b, c, d, e);}template<class A, class B, class C, class D, class E, class F>inline Tuple6<A, B, C, D, E, F> MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f){ return Tuple6<A, B, C, D, E, F>(a, b, c, d, e, f);}template<class A, class B, class C, class D, class E, class F, class G>inline Tuple7<A, B, C, D, E, F, G> MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g){ return Tuple7<A, B, C, D, E, F, G>(a, b, c, d, e, f, g);}template<class A, class B, class C, class D, class E, class F, class G,class H> inline Tuple8<A, B, C, D, E, F, G, H> MakeTuple(const A& a, const B& b, const C& c, const D& d, const E& e, const F& f, const G& g, const H& h){ return Tuple8<A, B, C, D, E, F, G, H>(a, b, c, d, e, f, g, h);}// The following set of helpers make what Boost refers to as "Tiers" - a tuple// of references.template<class A>inline Tuple1<A&> MakeRefTuple(A& a){ return Tuple1<A&>(a);}template<class A, class B>inline Tuple2<A&, B&> MakeRefTuple(A& a, B& b){ return Tuple2<A&, B&>(a, b);}template<class A, class B, class C>inline Tuple3<A&, B&, C&> MakeRefTuple(A& a, B& b, C& c){ return Tuple3<A&, B&, C&>(a, b, c);}template<class A, class B, class C, class D>inline Tuple4<A&, B&, C&, D&> MakeRefTuple(A& a, B& b, C& c, D& d){ return Tuple4<A&, B&, C&, D&>(a, b, c, d);}template<class A, class B, class C, class D, class E>inline Tuple5<A&, B&, C&, D&, E&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e){ return Tuple5<A&, B&, C&, D&, E&>(a, b, c, d, e);}template<class A, class B, class C, class D, class E, class F>inline Tuple6<A&, B&, C&, D&, E&, F&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e, F& f){ return Tuple6<A&, B&, C&, D&, E&, F&>(a, b, c, d, e, f);}template<class A, class B, class C, class D, class E, class F, class G>inline Tuple7<A&, B&, C&, D&, E&, F&, G&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e, F& f, G& g){ return Tuple7<A&, B&, C&, D&, E&, F&, G&>(a, b, c, d, e, f, g);}template<class A, class B, class C, class D, class E, class F, class G,class H> inline Tuple8<A&, B&, C&, D&, E&, F&, G&, H&> MakeRefTuple(A& a, B& b, C& c, D& d, E& e, F& f, G& g, H& h){ return Tuple8<A&, B&, C&, D&, E&, F&, G&, H&>(a, b, c, d, e, f, g, h);}// Dispatchers ----------------------------------------------------------------//// Helper functions that call the given method on an object, with the unpacked// tuple arguments. Notice that they all have the same number of arguments,// so you need only write:// DispatchToMethod(object, &Object::method, args);// This is very useful for templated dispatchers, since they don't need to know// what type |args| is.// Non-Static Dispatchers with no out params.template<class ObjT, class Method>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg){ (obj->*method)();}template<class ObjT, class Method, class A>inline void DispatchToMethod(ObjT* obj, Method method, const A& arg){ (obj->*method)(arg);}template<class ObjT, class Method, class A>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg){ (obj->*method)(arg.a);}template<class ObjT, class Method, class A, class B>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2<A, B>& arg){ (obj->*method)(arg.a, arg.b);}template<class ObjT, class Method, class A, class B, class C>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3<A, B, C>& arg){ (obj->*method)(arg.a, arg.b, arg.c);}template<class ObjT, class Method, class A, class B, class C, class D>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4<A, B, C, D>& arg){ (obj->*method)(arg.a, arg.b, arg.c, arg.d);}template<class ObjT, class Method, class A, class B, class C, class D, class E>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5<A, B, C, D, E>& arg){ (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e);}template<class ObjT, class Method, class A, class B, class C, class D, class E,class F> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6<A, B, C, D, E, F>& arg){ (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f);}template<class ObjT, class Method, class A, class B, class C, class D, class E,class F, class G> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple7<A, B, C, D, E, F, G>& arg){ (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f, arg.g);}// Static Dispatchers with no out params.template<class Function>inline void DispatchToFunction(Function function, const Tuple0& arg){ (*function)();}template<class Function, class A>inline void DispatchToFunction(Function function, const A& arg){ (*function)(arg);}template<class Function, class A>inline void DispatchToFunction(Function function, const Tuple1<A>& arg){ (*function)(arg.a);}template<class Function, class A, class B>inline void DispatchToFunction(Function function, const Tuple2<A, B>& arg){ (*function)(arg.a, arg.b);}template<class Function, class A, class B, class C>inline void DispatchToFunction(Function function, const Tuple3<A, B, C>& arg){ (*function)(arg.a, arg.b, arg.c);}template<class Function, class A, class B, class C, class D>inline void DispatchToFunction(Function function, const Tuple4<A, B, C, D>& arg){ (*function)(arg.a, arg.b, arg.c, arg.d);}template<class Function, class A, class B, class C, class D, class E>inline void DispatchToFunction(Function function, const Tuple5<A, B, C, D, E>& arg){ (*function)(arg.a, arg.b, arg.c, arg.d, arg.e);}template<class Function, class A, class B, class C, class D, class E, class F>inline void DispatchToFunction(Function function, const Tuple6<A, B, C, D, E, F>& arg){ (*function)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f);}template<class Function, class A, class B, class C, class D, class E, class F,class G> inline void DispatchToFunction(Function function, const Tuple7<A, B, C, D, E, F, G>& arg){ (*function)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f, arg.g);}template<class Function, class A, class B, class C, class D, class E, class F,class G, class H> inline void DispatchToFunction(Function function, const Tuple8<A, B, C, D, E, F, G, H>& arg){ (*function)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f, arg.g, arg.h);}// Dispatchers with 0 out param (as a Tuple0).template<class ObjT, class Method>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& arg, Tuple0*){ (obj->*method)();}template<class ObjT, class Method, class A>inline void DispatchToMethod(ObjT* obj, Method method, const A& arg, Tuple0*){ (obj->*method)(arg);}template<class ObjT, class Method, class A>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<A>& arg, Tuple0*){ (obj->*method)(arg.a);}template<class ObjT, class Method, class A, class B>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2<A, B>& arg, Tuple0*){ (obj->*method)(arg.a, arg.b);}template<class ObjT, class Method, class A, class B, class C>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3<A, B, C>& arg, Tuple0*){ (obj->*method)(arg.a, arg.b, arg.c);}template<class ObjT, class Method, class A, class B, class C, class D>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4<A, B, C, D>& arg, Tuple0*){ (obj->*method)(arg.a, arg.b, arg.c, arg.d);}template<class ObjT, class Method, class A, class B, class C, class D, class E>inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5<A, B, C, D, E>& arg, Tuple0*){ (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e);}template<class ObjT, class Method, class A, class B, class C, class D, class E,class F> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6<A, B, C, D, E, F>& arg, Tuple0*){ (obj->*method)(arg.a, arg.b, arg.c, arg.d, arg.e, arg.f);}// Dispatchers with 1 out param.template<class ObjT, class Method,class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple1<OutA>* out){ (obj->*method)(&out->a);}template<class ObjT, class Method, class InA,class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple1<OutA>* out){ (obj->*method)(in, &out->a);}template<class ObjT, class Method, class InA,class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<InA>& in, Tuple1<OutA>* out){ (obj->*method)(in.a, &out->a);}template<class ObjT, class Method, class InA, class InB,class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2<InA, InB>& in, Tuple1<OutA>* out){ (obj->*method)(in.a, in.b, &out->a);}template<class ObjT, class Method, class InA, class InB, class InC,class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3<InA, InB, InC>& in, Tuple1<OutA>* out){ (obj->*method)(in.a, in.b, in.c, &out->a);}template<class ObjT, class Method, class InA, class InB, class InC, class InD,class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4<InA, InB, InC, InD>& in, Tuple1<OutA>* out){ (obj->*method)(in.a, in.b, in.c, in.d, &out->a);}template<class ObjT, class Method, class InA, class InB, class InC, class InD,class InE, class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5<InA, InB, InC, InD, InE>& in, Tuple1<OutA>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE, class InF,class OutA> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6<InA, InB, InC, InD, InE, InF>& in, Tuple1<OutA>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a);}// Dispatchers with 2 out params.template<class ObjT, class Method,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple2<OutA, OutB>* out){ (obj->*method)(&out->a, &out->b);}template<class ObjT, class Method, class InA,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple2<OutA, OutB>* out){ (obj->*method)(in, &out->a, &out->b);}template<class ObjT, class Method, class InA,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<InA>& in, Tuple2<OutA, OutB>* out){ (obj->*method)(in.a, &out->a, &out->b);}template<class ObjT, class Method, class InA, class InB,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2<InA, InB>& in, Tuple2<OutA, OutB>* out){ (obj->*method)(in.a, in.b, &out->a, &out->b);}template<class ObjT, class Method, class InA, class InB, class InC,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3<InA, InB, InC>& in, Tuple2<OutA, OutB>* out){ (obj->*method)(in.a, in.b, in.c, &out->a, &out->b);}template<class ObjT, class Method, class InA, class InB, class InC, class InD,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4<InA, InB, InC, InD>& in, Tuple2<OutA, OutB>* out){ (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5<InA, InB, InC, InD, InE>& in, Tuple2<OutA, OutB>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a, &out->b);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE, class InF,class OutA, class OutB> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6<InA, InB, InC, InD, InE, InF>& in, Tuple2<OutA, OutB>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a, &out->b);}// Dispatchers with 3 out params.template<class ObjT, class Method,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(&out->a, &out->b, &out->c);}template<class ObjT, class Method, class InA,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(in, &out->a, &out->b, &out->c);}template<class ObjT, class Method, class InA,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<InA>& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(in.a, &out->a, &out->b, &out->c);}template<class ObjT, class Method, class InA, class InB,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2<InA, InB>& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(in.a, in.b, &out->a, &out->b, &out->c);}template<class ObjT, class Method, class InA, class InB, class InC,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3<InA, InB, InC>& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(in.a, in.b, in.c, &out->a, &out->b, &out->c);}template<class ObjT, class Method, class InA, class InB, class InC, class InD,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4<InA, InB, InC, InD>& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b, &out->c);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5<InA, InB, InC, InD, InE>& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a, &out->b, &out->c);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE, class InF,class OutA, class OutB, class OutC> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6<InA, InB, InC, InD, InE, InF>& in, Tuple3<OutA, OutB, OutC>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a, &out->b, &out->c);}// Dispatchers with 4 out params.template<class ObjT, class Method,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(&out->a, &out->b, &out->c, &out->d);}template<class ObjT, class Method, class InA,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(in, &out->a, &out->b, &out->c, &out->d);}template<class ObjT, class Method, class InA,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<InA>& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(in.a, &out->a, &out->b, &out->c, &out->d);}template<class ObjT, class Method, class InA, class InB,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2<InA, InB>& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(in.a, in.b, &out->a, &out->b, &out->c, &out->d);}template<class ObjT, class Method, class InA, class InB, class InC,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3<InA, InB, InC>& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(in.a, in.b, in.c, &out->a, &out->b, &out->c, &out->d);}template<class ObjT, class Method, class InA, class InB, class InC, class InD,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4<InA, InB, InC, InD>& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b, &out->c, &out->d);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5<InA, InB, InC, InD, InE>& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a, &out->b, &out->c, &out->d);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE, class InF,class OutA, class OutB, class OutC, class OutD> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6<InA, InB, InC, InD, InE, InF>& in, Tuple4<OutA, OutB, OutC, OutD>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a, &out->b, &out->c, &out->d);}// Dispatchers with 5 out params.template<class ObjT, class Method,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple0& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(&out->a, &out->b, &out->c, &out->d, &out->e);}template<class ObjT, class Method, class InA,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const InA& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(in, &out->a, &out->b, &out->c, &out->d, &out->e);}template<class ObjT, class Method, class InA,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple1<InA>& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(in.a, &out->a, &out->b, &out->c, &out->d, &out->e);}template<class ObjT, class Method, class InA, class InB,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple2<InA, InB>& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(in.a, in.b, &out->a, &out->b, &out->c, &out->d, &out->e);}template<class ObjT, class Method, class InA, class InB, class InC,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple3<InA, InB, InC>& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(in.a, in.b, in.c, &out->a, &out->b, &out->c, &out->d, &out->e);}template<class ObjT, class Method, class InA, class InB, class InC, class InD,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple4<InA, InB, InC, InD>& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(in.a, in.b, in.c, in.d, &out->a, &out->b, &out->c, &out->d, &out->e);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple5<InA, InB, InC, InD, InE>& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, &out->a, &out->b, &out->c, &out->d, &out->e);}template<class ObjT, class Method,class InA, class InB, class InC, class InD, class InE, class InF,class OutA, class OutB, class OutC, class OutD, class OutE> inline void DispatchToMethod(ObjT* obj, Method method, const Tuple6<InA, InB, InC, InD, InE, InF>& in, Tuple5<OutA, OutB, OutC, OutD, OutE>* out){ (obj->*method)(in.a, in.b, in.c, in.d, in.e, in.f, &out->a, &out->b, &out->c, &out->d, &out->e);}#endif //__tuple_h__ 0 0
- 异步线程任务封装
- Thread利用线程池封装异步任务【基础版】
- c++ 线程并发、任务队列、异步 任务封装和分发 lambda与任务 boost
- 子线程异步任务
- 线程之异步任务
- Android异步线程框架封装
- Android异步线程AsyncTask封装
- 线程：后台异步任务AsyncTask
- *【线程优化】AsyncTask 异步任务
- 基于任务的线程封装
- Android_RxJava2.0封装异步任务RxAsyncTask
- Android 异步任务 代码很简短，简单异步工具封装，方便执行异步任务
- winform UI后台异步工作线程封装
- 模拟线程池，处理异步任务
- AsyncTask异步任务线程框架（一）
- AsyncTask异步任务线程框架（二）
- UI线程和异步任务AsyncTask
- Android异步任务处理之Thread线程
- elasticsearch 开始
- git在window下的安装注意问题
- 系统架构设计师认证笔记之一：方向要点
- android开发之Android SDK更新出现Connection to http://dl-ssl.google.com refused 的解决办法
- Android View绘制流程
- 异步线程任务封装
- Java工具类——把金额转换成汉字大写金额
- js基本包装类型
- 中国社会的阶层划分
- netbeans的svn
- 【笔试】诺西二
- Struts2实现国际化
- CDT 出现 program is not a recognized executable
- linux常用命令
