swift - The command pattern

The command pattern provides a mechanism by which details of how to invoke a method can beencapsulated so that the method can be invoked later or by a different component.  

命令模式：把每一次执行的命令放到一个队列里，undo队列 和 do队列，实现了undo/redo的操作。

client:

let calc = Calculator();

calc.add(10);

calc.multiply(4);

calc.subtract(2);

println("Calc 1 Total: \(calc.total)");

let macro = calc.getMacroCommand();

let calc2 = Calculator();

macro(calc2);

println("Calc 2 Total: \(calc2.total)");

///

pattern:

//1

import Foundation;

class Calculator {

    private(set) var total = 0;

    typealias CommandClosure = (Calculator -> Void);

    private var history = [CommandClosure]();

    private var queue = dispatch_queue_create("arrayQ", DISPATCH_QUEUE_SERIAL);

    

    func add(amount:Int) {

        addMacro(Calculator.add, amount: amount);

        total += amount;

    }

    

    func subtract(amount:Int) {

        addMacro(Calculator.subtract, amount: amount);

        total -= amount;

    }

    

    func multiply(amount:Int) {

        addMacro(Calculator.multiply, amount: amount);

        total = total * amount;

    }

    

    func divide(amount:Int) {

        addMacro(Calculator.divide, amount: amount);

        total = total / amount;

    }

    

    private func addMacro(method:Calculator -> Int -> Void, amount:Int) {

        dispatch_sync(self.queue, {() in

            self.history.append({ calc in  method(calc)(amount)});

        });

    }

    

    func getMacroCommand() -> (Calculator -> Void) {

        var commands = [CommandClosure]();

        dispatch_sync(queue, {() in

            commands = self.history

        });

        return { calc in

            if (commands.count > 0) {

                for index in 0 ..< commands.count {

                    commands[index](calc);

                }

            }

        };

    }

}

//2

protocol Command {

    func execute(receiver:Any);

}

class CommandWrapper : Command {

    private let commands:[Command];

    

    init(commands:[Command]) {

        self.commands = commands;

    }

    

    func execute(receiver:Any) {

        for command in commands {

            command.execute(receiver);

        }

    }

}

class GenericCommand<T> : Command {

    private var instructions: T -> Void;

    

    init(instructions: T -> Void) {

        self.instructions = instructions;

    }

    

    func execute(receiver:Any) {

        if let safeReceiver = receiver as? T {

            instructions(safeReceiver);

        } else {

            fatalError("Receiver is not expected type");

        }

    }

    

    class func createCommand(instuctions: T -> Void) -> Command {

        return GenericCommand(instructions: instuctions);

    }

}