Undo/Redo框架（C++，带源码）

#pragma once



#include "UndoRedo\BaseCommandReceiver.h"



class Invoker;



class MockCommandReceiver : public BaseCommandReceiver

{

public:

    MockCommandReceiver();

    ~MockCommandReceiver();



    virtual bool Action(bool bUndo);



    void PrepareData(Invoker * pInvoker, int nParameter);



public:

    int m_nData;

    Invoker * m_pInvoker;

};

#include "StdAfx.h"

#include <iostream>

#include "MockCommandReceiver.h"

#include "Invoker.h"



RegisterCommandReceiverClass<MockCommandReceiver> RegisterCommandReceiverClass(ClassNameToString(MockCommandReceiver));



MockCommandReceiver::MockCommandReceiver():

m_pInvoker(NULL),

m_nData(0)

{

}



MockCommandReceiver::~MockCommandReceiver()

{

}



bool MockCommandReceiver::Action(bool bUndo)

{

    if (bUndo)

    {

        if (!m_pInvoker)

        {

            return false;

        }

        else

        {

            m_pInvoker->PopElement();

        }

    }

    else

    {

        if (!m_pInvoker)

        {

            return false;

        }

        else

        {

            m_pInvoker->PushElement(m_nData);

        }

    }



    return true;

}



void MockCommandReceiver::PrepareData(Invoker * pInvoker, int nParameter)

{

    m_pInvoker = pInvoker;

    m_nData = nParameter;

}

 

下面的测试用例中，有个对命令执行失败情况的测试，所以声明MockCommand来模拟执行成功和失败。

 

#pragma once



#include "UndoRedo\BaseCommand.h"



class MockCommand : public BaseCommand

{

public:

    MockCommand();

    virtual ~MockCommand();



    virtual bool Execute();

    virtual bool Unexecute();



    void PrepareData(bool bReturnTrue);



private:

    bool m_bReturnTrue;

};

#include "StdAfx.h"

#include <iostream>

#include "MockCommand.h"



RegisterCommandClass<MockCommand> RegisterCommandClass(ClassNameToString(MockCommand));



MockCommand::MockCommand():

m_bReturnTrue(true)

{

}



MockCommand::~MockCommand()

{

}



bool MockCommand::Execute()

{

    // 在此增加命令的执行代码

    std::cout << "Mock command is executing. Return " << (m_bReturnTrue?"true":"false") << ".\n\n";

    return m_bReturnTrue;

}



bool MockCommand::Unexecute()

{

    // 在此增加命令的撤销代码

    std::cout << "Mock command is unexecuting. Return " << (m_bReturnTrue?"true":"false") << ".\n\n";

    return m_bReturnTrue;

}



void MockCommand::PrepareData(bool bReturnTrue)

{

    m_bReturnTrue = bReturnTrue;

}

 

要测试的内容包括：

 

1.       简单命令的调用、撤销和恢复

2.       组合命令的调用、撤销和恢复

3.       清除所有命令

4.       在撤销一个命令后调用另一个命令

5.       失败的命令调用、撤销和恢复

6.       大量的命令调用、撤销和恢复

7.       以上操作后，Undoable/Redoable的状态

 

每个用例的目的、步骤和期望结果就不赘述了，看代码吧。

 

TEST_F(Invoker, TestUndoRedoFramework)

{

    std::cout << "----- Test simple command and undo/redo -----\n\n";



    std::cout << "Execute\n";

    int nElement1 = 1;

    CALLCOMMAND(ConstructCommand(nElement1));

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);

    int expect = 1;

    int actual = m_listElements.size();

    ASSERT_EQ(expect, actual);

    expect = nElement1;

    std::list<int>::const_iterator iter = m_listElements.begin();

    actual = *iter;

    ASSERT_EQ(expect, actual);



    std::cout << "Execute\n";

    int nElement2 = 2;

    CALLCOMMAND(ConstructCommand(nElement2));

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);

    expect = 2;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);

    expect = nElement1;

    iter = m_listElements.begin();

    actual = *iter;

    ASSERT_EQ(expect, actual);

    expect = nElement2;

    actual = *(++iter);

    ASSERT_EQ(expect, actual);



    std::cout << "Undo\n";

    UNDO;

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_TRUE(CANREDO);

    expect = 1;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);



    std::cout << "Redo\n";

    REDO;

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);

    expect = 2;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);

    expect = nElement1;

    iter = m_listElements.begin();

    actual = *iter;

    ASSERT_EQ(expect, actual);

    expect = nElement2;

    actual = *(++iter);

    ASSERT_EQ(expect, actual);



    std::cout << "Undo twice\n";

    UNDO;

    UNDO;

    DisplayList();



    ASSERT_FALSE(CANUNDO);

    ASSERT_TRUE(CANREDO);

    expect = 0;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);



    std::cout << "Redo twice\n";

    REDO;

    REDO;

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);

    expect = 2;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);

    expect = nElement1;

    iter = m_listElements.begin();

    actual = *iter;

    ASSERT_EQ(expect, actual);

    expect = nElement2;

    actual = *(++iter);

    ASSERT_EQ(expect, actual);



    std::cout << "----- Test clear all commands -----\n\n";



    std::cout << "Clear all commands\n";

    CLEARALLCOMMANDS;



    ASSERT_FALSE(CANUNDO);

    ASSERT_FALSE(CANREDO);



    std::cout << "----- Test macro command -----\n\n";



    CLEARALLCOMMANDS;

    ClearAllElements();



    std::cout << "Execute\n";

    MacroCommand * pMacroCommand = (MacroCommand *)CREATECOMMAND(MacroCommand);

    int nElement3 = 3;

    pMacroCommand->AddCommand(ConstructCommand(nElement3));

    int nElement4 = 4;

    pMacroCommand->AddCommand(ConstructCommand(nElement4));

    int nElement5 = 5;

    pMacroCommand->AddCommand(ConstructCommand(nElement5));

    CALLCOMMAND(pMacroCommand);

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);

    expect = 3;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);



    std::cout << "Undo\n";

    UNDO;

    DisplayList();



    ASSERT_FALSE(CANUNDO);

    ASSERT_TRUE(CANREDO);

    expect = 0;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);



    std::cout << "Redo\n";

    REDO;

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);

    expect = 3;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);

    std::vector<int> vecElements;

    vecElements.push_back(nElement3);

    vecElements.push_back(nElement4);

    vecElements.push_back(nElement5);

    int i = 0;

    for (iter = m_listElements.begin(); iter != m_listElements.end(); iter++, i++)

    {

        expect = vecElements[i];

        actual = *iter;

        ASSERT_EQ(expect, actual);

    }



    std::cout << "----- Test command called after undo -----\n\n";



    CLEARALLCOMMANDS;

    ClearAllElements();



    std::cout << "Execute\n";

    int nElement6 = 6;

    CALLCOMMAND(ConstructCommand(nElement6));

    DisplayList();

    std::cout << "Undo\n";

    UNDO;

    DisplayList();

    std::cout << "Execute\n";

    int nElement7 = 7;

    CALLCOMMAND(ConstructCommand(nElement7));

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);

    expect = 1;

    actual = m_listElements.size();

    ASSERT_EQ(expect, actual);

    expect = nElement7;

    iter = m_listElements.begin();

    actual = *iter;

    ASSERT_EQ(expect, actual);



    std::cout << "----- Test failed command and undo/redo -----\n\n";



    CLEARALLCOMMANDS;

    ClearAllElements();



    MockCommand * pMockCommand = (MockCommand *)CREATECOMMAND(MockCommand);

    pMockCommand->PrepareData(true);

    std::cout << "Execute\n";

    CALLCOMMAND(pMockCommand);

    std::cout << "Undo\n";

    UNDO;

    std::cout << "Redo\n";

    REDO;



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);



    pMockCommand->PrepareData(false);

    std::cout << "Undo\n";

    UNDO;



    ASSERT_FALSE(CANUNDO);

    ASSERT_FALSE(CANREDO);



    pMockCommand = (MockCommand *)CREATECOMMAND(MockCommand);

    pMockCommand->PrepareData(true);

    std::cout << "Execute\n";

    CALLCOMMAND(pMockCommand);

    std::cout << "Undo\n";

    UNDO;



    ASSERT_FALSE(CANUNDO);

    ASSERT_TRUE(CANREDO);



    pMockCommand->PrepareData(false);

    std::cout << "Redo\n";

    REDO;



    ASSERT_FALSE(CANUNDO);

    ASSERT_FALSE(CANREDO);



    std::cout << "----- Test lots of commands and undo/redo -----\n\n";



    CLEARALLCOMMANDS;



    const int nCount = 300;

    for (i = 0; i < nCount; i++)

    {

        CALLCOMMAND(ConstructCommand(i));

    }

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);



    for (i = 0; i < nCount; i++)

    {

        UNDO;

    }

    DisplayList();



    ASSERT_FALSE(CANUNDO);

    ASSERT_TRUE(CANREDO);



    for (i = 0; i < nCount; i++)

    {

        REDO;

    }

    DisplayList();



    ASSERT_TRUE(CANUNDO);

    ASSERT_FALSE(CANREDO);



    CLEARALLCOMMANDS;



    ASSERT_FALSE(CANUNDO);

    ASSERT_FALSE(CANREDO);

}

 

后记

 

有人说：“你罗罗嗦嗦地说这么多，不就是个Undo/Redo框架么，至于这么费劲么？”不错，说得确实有点罗嗦。不过，在实际的工作中，对以上每一个技术细节的思考都是不可缺少的。当你的代码将被别人使用的时候，多费点精力在稳定性、可复用性、可扩展性等方面，还是很值得的。

 

以上内容，如有谬误，敬请指出，先谢过了！

 

请点击此处下载源代码

 

参考资料

 

《设计模式 - 可复用面向对象软件的基础》5.2 Command（命令）- 对象行为型模式

《Head First设计模式》6 封装调用：命令模式

《敏捷软件开发 - 原则、模式与实践（C#版）》第21章 COMMAND模式

《C++设计新思维》部分章节

《Getting started with Google C++ Testing Framework》