Commandパターン調査ドキュメント

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

操作履歴スタック:
1. InsertTextCommand("Hello")
2. DeleteTextCommand(range: 0-2)
3. FormatCommand(bold: true)

Undo実行時:
- スタックから最新のコマンドをpop
- コマンドのundo()メソッドを呼び出し
- Redoスタックにpush

Redo実行時:
- Redoスタックからpop
- コマンドのexecute()メソッドを再実行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// マクロコマンド（複合コマンド）
public class SleepModeCommand implements Command {
    private Command[] commands;
    
    public SleepModeCommand(Command[] commands) {
        this.commands = commands;
    }
    
    public void execute() {
        for (Command cmd : commands) {
            cmd.execute();
        }
    }
}

// 使用例
Command[] sleepCommands = {
    new LightOffCommand(bedroomLight),
    new ThermostatSetCommand(thermostat, 20),
    new LockDoorCommand(frontDoor),
    new AlarmSetCommand(alarm, "07:00")
};
Command sleepMode = new SleepModeCommand(sleepCommands);
remoteControl.setCommand(sleepMode);

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100

// Command インターフェース
public interface Command {
    void execute();
    void undo();
}

// Receiver（実際の処理を行うオブジェクト）
public class Light {
    private String location;
    
    public Light(String location) {
        this.location = location;
    }
    
    public void on() {
        System.out.println(location + " light is ON");
    }
    
    public void off() {
        System.out.println(location + " light is OFF");
    }
}

// ConcreteCommand（具体的なコマンド）
public class LightOnCommand implements Command {
    private Light light;
    
    public LightOnCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.on();
    }
    
    @Override
    public void undo() {
        light.off();
    }
}

public class LightOffCommand implements Command {
    private Light light;
    
    public LightOffCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.off();
    }
    
    @Override
    public void undo() {
        light.on();
    }
}

// Invoker（コマンドを実行する側）
public class RemoteControl {
    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void pressButton() {
        command.execute();
    }
    
    public void pressUndo() {
        command.undo();
    }
}

// Client（コマンドを組み立てる）
public class Client {
    public static void main(String[] args) {
        // Receiverを作成
        Light livingRoomLight = new Light("Living Room");
        
        // ConcreteCommandを作成
        Command lightsOn = new LightOnCommand(livingRoomLight);
        Command lightsOff = new LightOffCommand(livingRoomLight);
        
        // Invokerを作成
        RemoteControl remote = new RemoteControl();
        
        // コマンドを設定して実行
        remote.setCommand(lightsOn);
        remote.pressButton();  // "Living Room light is ON"
        
        remote.pressUndo();    // "Living Room light is OFF"
        
        remote.setCommand(lightsOff);
        remote.pressButton();  // "Living Room light is OFF"
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

# Command インターフェース
class Command:
    def execute(self):
        pass
    
    def undo(self):
        pass

# Receiver
class Light:
    def __init__(self, location):
        self.location = location
        self.is_on = False
    
    def turn_on(self):
        self.is_on = True
        print(f"{self.location} light is ON")
    
    def turn_off(self):
        self.is_on = False
        print(f"{self.location} light is OFF")

# ConcreteCommand
class LightOnCommand(Command):
    def __init__(self, light):
        self.light = light
    
    def execute(self):
        self.light.turn_on()
    
    def undo(self):
        self.light.turn_off()

class LightOffCommand(Command):
    def __init__(self, light):
        self.light = light
    
    def execute(self):
        self.light.turn_off()
    
    def undo(self):
        self.light.turn_on()

# Invoker
class RemoteControl:
    def __init__(self):
        self.command = None
        self.history = []
    
    def set_command(self, command):
        self.command = command
    
    def press_button(self):
        if self.command:
            self.command.execute()
            self.history.append(self.command)
    
    def press_undo(self):
        if self.history:
            last_command = self.history.pop()
            last_command.undo()

# 使用例
if __name__ == "__main__":
    # Receiverを作成
    bedroom_light = Light("Bedroom")
    
    # Commandを作成
    lights_on = LightOnCommand(bedroom_light)
    lights_off = LightOffCommand(bedroom_light)
    
    # Invokerを作成
    remote = RemoteControl()
    
    # 実行
    remote.set_command(lights_on)
    remote.press_button()  # "Bedroom light is ON"
    
    remote.press_undo()    # "Bedroom light is OFF"

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

// Command インターフェース
interface Command {
    execute(): void;
    undo(): void;
}

// Receiver
class TextEditor {
    private content: string = '';
    
    insert(text: string): void {
        this.content += text;
        console.log(`Content: "${this.content}"`);
    }
    
    delete(length: number): void {
        this.content = this.content.slice(0, -length);
        console.log(`Content: "${this.content}"`);
    }
    
    getContent(): string {
        return this.content;
    }
}

// ConcreteCommand
class InsertCommand implements Command {
    private editor: TextEditor;
    private text: string;
    
    constructor(editor: TextEditor, text: string) {
        this.editor = editor;
        this.text = text;
    }
    
    execute(): void {
        this.editor.insert(this.text);
    }
    
    undo(): void {
        this.editor.delete(this.text.length);
    }
}

class DeleteCommand implements Command {
    private editor: TextEditor;
    private deletedText: string;
    private length: number;
    
    constructor(editor: TextEditor, length: number) {
        this.editor = editor;
        this.length = length;
        this.deletedText = '';
    }
    
    execute(): void {
        const content = this.editor.getContent();
        this.deletedText = content.slice(-this.length);
        this.editor.delete(this.length);
    }
    
    undo(): void {
        this.editor.insert(this.deletedText);
    }
}

// Invoker with history
class CommandManager {
    private history: Command[] = [];
    private currentIndex: number = -1;
    
    executeCommand(command: Command): void {
        // 新しいコマンドを実行すると、それ以降の履歴は削除
        this.history = this.history.slice(0, this.currentIndex + 1);
        
        command.execute();
        this.history.push(command);
        this.currentIndex++;
    }
    
    undo(): void {
        if (this.currentIndex >= 0) {
            const command = this.history[this.currentIndex];
            command.undo();
            this.currentIndex--;
        }
    }
    
    redo(): void {
        if (this.currentIndex < this.history.length - 1) {
            this.currentIndex++;
            const command = this.history[this.currentIndex];
            command.execute();
        }
    }
}

// 使用例
const editor = new TextEditor();
const manager = new CommandManager();

manager.executeCommand(new InsertCommand(editor, "Hello "));
// Content: "Hello "

manager.executeCommand(new InsertCommand(editor, "World"));
// Content: "Hello World"

manager.undo();
// Content: "Hello "

manager.redo();
// Content: "Hello World"

manager.executeCommand(new DeleteCommand(editor, 6));
// Content: "Hello"

manager.undo();
// Content: "Hello World"