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 这两点 。  

 

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