一个实现恢复删除机制(do undo)的设计

BaseOperation.h

/*----------------------------------------------------------
desc   : 编辑器中各种操作的接口类。
author   : zilong
version   : 1.0
date   : 2011-03-23

revision:

----------------------------------------------------------*/

#pragma once

class IBaseOperation
{
public:
   IBaseOperation(void);
   virtual ~IBaseOperation(void);

   //每个operation应该保证在没有成功的情况下自己回滚（即不改变数据库）。
   virtual bool Excute(void) = 0;

   void SetStatus(bool bExcuted_);

protected:
   bool m_bExcuted;
};

//一对相反的操作
class COpertaionPair
{
public:
   COpertaionPair(IBaseOperation *do_, IBaseOperation *undo_);
   ~COpertaionPair();

   //回滚本操作，即本操作执行前的状态。
   bool Rollback(void);
   //执行本操作
   bool Excute(void);

   //本操作是否已执行
   bool IsExcuted(void){return m_bExcuted;};

private:
   IBaseOperation *m_do;
   IBaseOperation *m_undo;

   bool m_bExcuted;   //true, 已执行；false, 处于回滚后的状态。
};

BaseOperation.cpp

#include "BaseOperation.h"
#include <stdlib.h>
#include <assert.h>

IBaseOperation::IBaseOperation(void):
m_bExcuted(false)
{
}

IBaseOperation::~IBaseOperation(void)
{
}

void IBaseOperation::SetStatus(bool bExcuted_)
{
   m_bExcuted = bExcuted_;
}

COpertaionPair::COpertaionPair(IBaseOperation *do_, IBaseOperation *undo_):
m_do(do_),
m_undo(undo_),
m_bExcuted(false)
{

}

COpertaionPair::~COpertaionPair()
{

}

bool COpertaionPair::Rollback(void)
{
   assert(m_undo != NULL);
   if(!m_bExcuted)
       return false;

   m_bExcuted = false;

/*
   return m_undo->Excute();
*/
   bool ret = m_undo->Excute();
   if(ret)
   {
       m_undo->SetStatus(true);
       m_do->SetStatus(false);
   }

   return ret;
}

bool COpertaionPair::Excute(void)
{
   assert(m_do != NULL);
   if(m_bExcuted)
       return false;

   m_bExcuted = true;
/*
   return m_do->Excute();
*/

   bool ret = m_do->Excute();
   if(ret)
   {
       m_do->SetStatus(true);
       m_undo->SetStatus(false);
   }

   return ret;
}

RecoveryManager.h

/*----------------------------------------------------------
desc   : 恢复功能（undo redo）模块。
author   : zilong
version   : 1.0
date   : 2011-03-23

revision:

----------------------------------------------------------*/

#pragma once

#include <stack>

class COpertaionPair;

class CRecoveryManager
{
private:
   typedef std::stack<COpertaionPair *> TOperations;

public:
   CRecoveryManager(void);
   ~CRecoveryManager(void);

   //清空库
   void Clear(void);

   //是否可以回滚
   bool CanRollback(void);
   //是否可以向前滚动
   bool CanRoll(void);

   //执行一个操作，成功之后将该操作入库。
   bool Excute(COpertaionPair *operation_);
   //回滚一个操作。
   bool Rollback(void);
   //向前滚动一个操作。
   bool Roll(void);
   bool Rollback(int count_);
   bool Roll(int count_);

private:
   void ClearOpertaions(TOperations &_ops_);

private:
   TOperations m_undoes;   //
   TOperations m_redoes;
};

RecoveryManager.cpp

#include "RecoveryManager.h"
#include "rollback\BaseOperation.h"
#include <assert.h>

CRecoveryManager::CRecoveryManager(void)
{
}

CRecoveryManager::~CRecoveryManager(void)
{
   Clear();
}

void CRecoveryManager::Clear(void)
{
   ClearOpertaions(m_redoes);
   ClearOpertaions(m_undoes);
}

void CRecoveryManager::ClearOpertaions(TOperations &_ops_)
{
   while(!_ops_.empty())
   {
       delete _ops_.top();
       _ops_.pop();
   }
}

bool CRecoveryManager::CanRollback(void)
{
   return !m_undoes.empty();
}

bool CRecoveryManager::CanRoll(void)
{
   return !m_redoes.empty();
}

bool CRecoveryManager::Excute(COpertaionPair *operation_)
{
   assert(operation_ != NULL);
   if(NULL == operation_)
       return false;

   if(operation_->Excute())
   {
       ClearOpertaions(m_redoes);
       m_undoes.push(operation_);

       return true;
   }

   return false;
}

bool CRecoveryManager::Rollback(void)
{
   if(!CanRollback())
       return false;

   COpertaionPair *op = m_undoes.top();
   assert(op != NULL);
   if(op->Rollback())
   {
       m_undoes.pop();
       m_redoes.push(op);

       return true;
   }

   return false;
}

bool CRecoveryManager::Roll(void)
{
   if(!CanRoll())
       return false;

   COpertaionPair *op = m_redoes.top();
   assert(op != NULL);
   if(op->Excute())
   {
       m_redoes.pop();
       m_undoes.push(op);

       return true;
   }

   return false;
}

举个例子。例如，要写一个文本编辑器，其中要实现一个删除操作，且可以实现undo, redo.
class CDeleteTextOper: public IBaseOperation
{
public:
   CDeleteTextOper(CTextDataMgr *receiver);
   virtual ~CDeleteTextOper(void);

   virtual bool Excute(void)
   {
       m_pReceiver->DeleteText(m_head, m_tail);
   }

   void SetData(int head, int tail);

protected:
   CTextDataMgr *m_pReceiver;
   int m_head;
   int m_tail;
};

class CAddTextOper: public IBaseOperation
{
public:
   CAddTextOper(CTextDataMgr *receiver);
   virtual ~CAddTextOper(void);

   virtual bool Excute(void)
   {
       m_pReceiver->AddText(m_offset, txt);
   }

   void SetData(int offset, const std::string &txt);

protected:
   CTextDataMgr *m_pReceiver;
   int m_offset;
   std::string txt;
};

class CTextDataMgr
{
private:
   CRecoveryManager m_opManager;
public:
   std::string GetText(int head, int tail);

public:
   bool AddText(int offset, const std::string &txt);
   bool DeleteText(int head, int tail);

public:
   bool DoDeleteText(int head, int tail)
   {
       CDeleteTextOper *mydo = new CDeleteTextOper(this);
       mydo->SetData(head, tail);

       CAddTextOper *undo = new CAddTextOper(this);
       undo->SetData(head, this->GetText(head, tail));

       COpertaionPair *op = new COpertaionPair(mydo, undo);
       return m_opManager.Excute(op);
   }

public:
   virtual void Redo(void)
   {
       m_opManager.Roll();
   }

   virtual void Undo(void)
   {
       m_opManager.Rollback();
   }

   virtual bool CanRedo(void);
   virtual bool CanUndo(void);
};

客户端调用代码如下

void main()
{
   CTextDataMgr dataMgr;

   //……

   //执行操作
   dataMgr.DoDeleteText(10, 20);

   //undo
   dataMgr.Undo();

   //redo
   dataMgr.Redo();
}