نمط الأمر

جزء من قسم البرمجة كائنية التوجه في رحلة C++ على Coddy. الدرس 96 من 104.

يقوم نمط Command بتغليف طلب على هيئة كائن، مما يتيح لك تهيئة العملاء بطلبات مختلفة، أو وضع العمليات في قائمة انتظار، أو دعم وظيفة التراجع. وهو يفصل الكائن الذي يستدعي عمليةً ما عن الكائن الذي يعرف كيفية تنفيذها.

يتكوّن النمط من أربعة مكوّنات رئيسية: واجهة Command تحتوي على أسلوب execute()، وConcrete Commands تنفّذ إجراءات محددة، وReceiver ينفّذ العمل actual، وInvoker يطلق الأوامر:

#include <iostream>
#include <memory>
#include <vector>

// المستقبل - يعرف كيفية تنفيذ العمليات
class Light {
public:
    void turnOn() { std::cout << "Light is ON\n"; }
    void turnOff() { std::cout << "Light is OFF\n"; }
};

// واجهة الأمر
class Command {
public:
    virtual void execute() = 0;
    virtual void undo() = 0;
    virtual ~Command() = default;
};

// الأوامر الملموسة
class LightOnCommand : public Command {
    Light& light;
public:
    LightOnCommand(Light& l) : light(l) {}
    void execute() override { light.turnOn(); }
    void undo() override { light.turnOff(); }
};

class LightOffCommand : public Command {
    Light& light;
public:
    LightOffCommand(Light& l) : light(l) {}
    void execute() override { light.turnOff(); }
    void undo() override { light.turnOn(); }
};

// المستدعي
class RemoteControl {
    std::vector<std::unique_ptr<Command>> history;
public:
    void pressButton(std::unique_ptr<Command> cmd) {
        cmd->execute();
        history.push_back(std::move(cmd));
    }
    
    void pressUndo() {
        if (!history.empty()) {
            history.back()->undo();
            history.pop_back();
        }
    }
};

يخزّن كل command مرجعًا إلى مستقبِله ويستدعي الطريقة المناسبة عند تنفيذه. لا يعرف المستدعي الإجراء الذي سيحدث - بل يستدعي فقط execute(). ومن خلال تخزين commands في سجل، يمكنك تنفيذ التراجع بسهولة عبر استدعاء الطريقة undo() الخاصة بكل command.

استخدم Command عندما تحتاج إلى وضع العمليات في قائمة انتظار، أو تنفيذ التراجع/الإعادة، أو فصل مُرسل الطلب عن معالجه.

التحدي

سهل

لنُنشئ محرر نصوص مزوّدًا بوظيفة التراجع باستخدام نمط Command. ستنشئ نظامًا تُغلّف فيه عمليات التحرير (مثل إدراج النص وحذفه) في صورة كائنات أوامر، مما يتيح للمستخدمين تنفيذ الإجراءات ثم التراجع عنها بترتيب عكسي، تمامًا مثل محرر النصوص الحقيقي.

ستنظّم التعليمات البرمجية عبر أربعة ملفات:

TextDocument.h: أنشئ فئة المستقبل التي تحتفظ بمحتوى النص الفعلي وتتلاعب به.
يجب أن تخزّن فئة TextDocument محتوى المستند كسلسلة نصية. نفّذ هذه الأساليب:
- insertText(const std::string& text): تُلحق النص بنهاية المحتوى
- deleteText(int count): تزيل آخر count من الأحرف من المحتوى (لا تفعل شيئًا إذا تجاوز count طول المحتوى)
- getContent(): تُرجع المحتوى الحالي كمرجع const
Command.h: عرّف واجهة الأمر وفئات الأوامر Concrete.
أنشئ فئة Command مجردة تحتوي على الأساليب الافتراضية الخالصة execute() وundo()، بالإضافة إلى مدمّر افتراضي.

ثم نفّذ أمرين Concrete:
- InsertCommand: يأخذ مرجعًا إلى TextDocument وسلسلة نصية لإدراجها. عند تنفيذه، يُدرج النص. وعند التراجع عنه، يحذف العدد نفسه من الأحرف التي أُدرجت.
- DeleteCommand: يأخذ مرجعًا إلى TextDocument وعددًا من الأحرف المطلوب حذفها. ويحتاج إلى تخزين النص المحذوف حتى يتمكن من استعادته عند التراجع. عند تنفيذه، يزيل الأحرف من النهاية. وعند التراجع عنه، يُدرج النص المخزّن مرة أخرى.
TextEditor.h: أنشئ المستدعي الذي يدير تنفيذ الأوامر وسجلّها.
يجب أن تحتفظ فئة TextEditor بمرجع إلى TextDocument وأن تحافظ على سجل بالأوامر المنفذة باستخدام متجه من unique_ptr<Command>. نفّذ ما يلي:
- executeCommand(std::unique_ptr<Command> cmd): ينفّذ الأمر ويضيفه إلى السجل
- undo(): يتراجع عن أحدث أمر ويزيله من السجل (لا يفعل شيئًا إذا كان السجل فارغًا)
- showContent(): يطبع محتوى المستند الحالي، أو [empty] إذا كان المحتوى فارغًا
main.cpp: اعرض نمط Command مع وظيفة التراجع.
اقرأ ثلاثة مُدخلات:
1. النص الأول المطلوب إدراجه (سلسلة نصية)
2. النص الثاني المطلوب إدراجه (سلسلة نصية)
3. عدد الأحرف المطلوب حذفها (عدد صحيح)
أنشئ كائنًا من TextDocument وكائنًا من TextEditor. ثم نفّذ العمليات التالية بالترتيب، مع عرض المحتوى بعد كل خطوة:
1. أدرج النص الأول، ثم اعرض المحتوى
2. أدرج النص الثاني، ثم اعرض المحتوى
3. احذف العدد المحدد من الأحرف، ثم اعرض المحتوى
4. تراجع مرة واحدة، ثم اعرض المحتوى
5. تراجع مرة أخرى، ثم اعرض المحتوى

على سبيل المثال، باستخدام المُدخلات Hello و World و3:

Hello
Hello World
Hello Wo
Hello World
Hello

وباستخدام المُدخلات Code وEditor و6:

Code
CodeEditor
Code
CodeEditor
Code

لاحظ كيف يعرف كل أمر كيفية عكس تأثيره. يتذكّر DeleteCommand ما حذفه حتى يتمكن من استعادته، بينما يعرف InsertCommand بالضبط عدد الأحرف التي يجب إزالتها عند التراجع. هذه هي قوة نمط Command: تصبح العمليات كائنات من الدرجة الأولى يمكن تخزينها وتنفيذها وعكسها.

جرّب بنفسك

#include <iostream>
#include <string>
#include <memory>
#include "TextDocument.h"
#include "Command.h"
#include "TextEditor.h"

int main() {
    // اقرأ المدخلات
    std::string firstText;
    std::string secondText;
    int deleteCount;
    
    std::getline(std::cin, firstText);
    std::getline(std::cin, secondText);
    std::cin >> deleteCount;

    // TODO: أنشئ TextDocument و TextEditor
    
    // TODO: نفّذ العمليات بالترتيب، مع عرض المحتوى بعد كل منها:
    // 1. أدرج النص الأول، ثم اعرض المحتوى
    // 2. أدرج النص الثاني، ثم اعرض المحتوى
    // 3. احذف العدد المحدد من الأحرف، ثم اعرض المحتوى
    // 4. تراجع مرة واحدة، ثم اعرض المحتوى
    // 5. تراجع مرة أخرى، ثم اعرض المحتوى
    
    // تلميح: استخدم std::make_unique<InsertCommand>(...) و 
    //       std::make_unique<DeleteCommand>(...) لإنشاء الأوامر

    return 0;
}