nim_duilib/base/framework/task.h

106 lines
3.6 KiB
C
Raw Normal View History

2019-04-19 17:19:57 +08:00
// This file defines all kinds of tasks
#ifndef BASE_FRAMEWORK_TASK_H_
#define BASE_FRAMEWORK_TASK_H_
#include "base/base_export.h"
#include "base/callback/callback.h"
namespace nbase
{
const size_t kDeadTask = 0xDEAD7A53;
// Task用于让某个MessageLoop异步地完成某项工作。
// Task对象本身是线程安全一个Task可以在同一个线程中生成并运行也可以在一个线程生成在另一个线程运行
// 后者的Run函数编写需要注意跨线程运行的问题。
// Task通过MessageLoop的Post族函数被加入到MessageLoop中运行
// 一旦被加入到MessageLoop中生成Task的线程不应该再负责Task的销毁而改由MessageLoop所运行的线程负责。
// RunnableMethodTraits --------------------------------------------------------
//
// This traits-class is used by RunnableMethod to manage the lifetime of the
// callee object. By default, it is assumed that the callee supports AddRef
// and Release methods. A particular class can specialize this template to
// define other lifetime management. For example, if the callee is known to
// live longer than the RunnableMethod object, then a RunnableMethodTraits
// struct could be defined with empty RetainCallee and ReleaseCallee methods.
template <class T>
struct RunnableMethodTraits
{
RunnableMethodTraits()
{
}
~RunnableMethodTraits()
{
}
void RetainCallee(T* obj)
{
obj->AddRef();
}
void ReleaseCallee(T* obj)
{
obj->Release();
}
};
// Convenience macro for declaring a RunnableMethodTraits that disables
// refcounting of a class. This is useful if you know that the callee
// will outlive the RunnableMethod object and thus do not need the ref counts.
//
// The invocation of DISABLE_RUNNABLE_METHOD_REFCOUNT should be done at the
// global namespace scope. Example:
//
// namespace foo {
// class Bar {
// ...
// };
// } // namespace foo
//
// DISABLE_RUNNABLE_METHOD_REFCOUNT(foo::Bar);
//
// This is different from DISALLOW_COPY_AND_ASSIGN which is declared inside the
// class.
#define DISABLE_RUNNABLE_METHOD_REFCOUNT(TypeName) \
template <> \
struct RunnableMethodTraits<TypeName> \
{ \
void RetainCallee(TypeName* manager) {} \
void ReleaseCallee(TypeName* manager) {} \
}
// RunnableMethod and RunnableFunction -----------------------------------------
//
// Runnable methods are a type of task that call a function on an object when
// they are run. We implement both an object and a set of NewRunnableMethod and
// NewRunnableFunction functions for convenience. These functions are
// overloaded and will infer the template types, simplifying calling code.
//
// The template definitions all use the following names:
// T - the class type of the object you're supplying
// this is not needed for the Static version of the call
// Method/Function - the signature of a pointer to the method or function you
// want to call
// Param - the parameter(s) to the method, possibly packed as a tuple
// A - the first parameter (if any) to the method
// B - the second parameter (if any) to the method
//
// Put these all together and you get an object that can call a method whose
// signature is:
// R T::MyFunction([A[, B]])
//
// Usage:
// PostTask(NewRunnableMethod(object, &Object::method[, a[, b]])
// PostTask(NewRunnableFunction(&function[, a[, b]])
// RunnableMethod and NewRunnableMethod implementation -------------------------
} // namespace nbase
#endif // BASE_FRAMEWORK_TASK_H_