8. 异步操作

对于游戏开发而言，经常使用到异步相关操作，因此在使用moduleframework之前应该提供一个异步操作的类。 以后相关的异步操作均继承这个类

AsyncOperation:

先贴出代码：

#ifndef __ASYNC_OPERATION_H__
#define __ASYNC_OPERATION_H__
#include <boost/function.hpp>

class AsyncOperation
{
public:
    typedef boost::function(void<AsyncOperation*>) TypeOnExecute;
    typedef boost::function(void<AsyncOperation*>) TypeOnComplete;
    typedef boost::function(void<AsyncOperation*>) TypeOnAborted;

    // 委托执行函数
    explicit AsyncOperation(TypeOnExecute onExecute)
        :_onExecute(onExecute)
    {
        if(!_onExecute) throw "onExecute is NULL";
    }

    virtual AsyncOperation(){}

    void Execute(TypeOnComplete onComplete, TypeOnAborted onAorted = NULL)
    {
        if (!_onComplete) throw "onComplete is NULL"
        _onComplete = onComplete;
        _onAborted = onAorted;
        _onExecute(this);
    }

    virtual void Abort()
    {

    }

    void Complete()
    {
        _onComplete(this);
    }

private:
    TypeOnExecute _onExecute;
    TypeOnComplete _onComplete;
    TypeOnAborted _onAborted;

};
#endif

真正的执行函数是Execute 另外提供了一个完成 和终止的接口。

这个类应该比较简单。

在此类的基础上构建一个异步队列。  AsyncQueue继承该类

#ifndef __ASYNC_QUEUE_H__
#define __ASYNC_QUEUE_H__

#include <glog/logging.h>
#include "AsyncOpertaion.hpp"
#include <boost/bind.hpp>
#include <deque>

using namespace std;

class AsyncQueue : public AsyncQueue
{
public:
    // 构造函数默认调用ExecuteNextChild来启动整个异步进程
    AsyncQueue(): AsyncOperation(boost::bind(&AsyncQueue::ExecuteNextChild, this, _1))
        , _abortFlag(false)
    {

    }
    ~AsyncQueue()
    {
        TypeOptQueue::iterator it = _queue.begin();
        for (; it != _queue.end(); ++it)
        {
            delete *it;
        }
    }

    // 加入队列
    void Push(AsyncOperation* operation)
    {
        _queue.push_back(operation);
    }

    // 终止执行
    void Abort()
    {
        if(_queue.empty()) return;
        _abortFlag = true;
        AsyncOperation* front = _queue.front();
        front->Abort(); // 终止队列首位的执行
    }

private:
    void ExecuteNextChild(AsyncOperation* operation)
    {
        if(_queue.empty())
        {
            LOG(ERROR) << "Async Queue is Empty!";
            return;
        }
        // 迭代执行_queue中的操作
        AsyncOperation* front = _queue.front();
        front->Execute(boost::bind(&AsyncQueue::OnChildComplete, this, _1));
    }

    void OnChildComplete(AsyncOperation* operation)
    {
        // 移除已执行的异步操作
        _queue.pop_front();
        delete operation;
        if (_queue.empty())
        {
            // 通知队列执行完成
            Complete();
            return;
        }

        if (_abortFlag && _onAborted)
        {
            _onAborted(this);
        }else
        {
            // 迭代执行
            ExecuteNextChild(0);
        }
    }

private:
    typedef deque<AsyncOperation*> TypeOptQueue; // 使用队列来包装
    TypeOptQueue _queue;
    bool _abortFlag; 
};

#endif

这里一个巧妙指出在于 如果迭代执行整个异步队列， 注意看 构造函数和OnExecuteNextChild 这两点 。  

至此我们构建了一个初步的异步队列。以后其他各个模块均继承他们。 比如模块的初始化等