Chain of responsibility 패턴, 명령(Command)패턴, 해석자(Interpreter)패턴

* Chain of responsibility ( 책임연쇄)

- 객체를 메시지로 보내는 함수 호출을 생각해보자. 이 메시지 전송 사고방식은 스몰토크 시대로 거슬러 올라감.
책임 연쇄 패턴은 메시지가 클래스에서 다른 클래스로 전달되는 접근 방식을 기술함.
클래스는 메시지를 처리하거나 체인에 있는 다음 멤버에게 전달함. 구현에 따라 메시지 전송에 몇 가지 다른 규칙을 적용할 수 있음
체인의 첫번째 일치하는 링크만이 메시지를 처리하도록 하거나, 또는 모든 일치하는 링크가 메시지를 처리할 수도 있음.
때때로 링크는 처리를 중지하거나, 메시지의 변종을 만들 수도 있음.

var Westeros;
(function (Westeros) {
    (function (JudicialSystem) {
        var Complaint = (function () {
            function Complaint() {
                this.ComplainingParty = "";
                this.ComplaintAbout = "";
                this.Complaint = "";
            }
            return Complaint;
        })();
        JudicialSystem.Complaint = Complaint;

        var ClerkOfTheCourt = (function () {
            function ClerkOfTheCourt() {
            }
            ClerkOfTheCourt.prototype.IsAbleToResolveComplaint = function (complaint) {
                //decide if this is a complaint which can be solved by the clerk
                return false;
            };

            ClerkOfTheCourt.prototype.ListenToComplaint = function (complaint) {
                //perform some operation
                //return solution to the complaint
                return "";
            };
            return ClerkOfTheCourt;
        })();
        JudicialSystem.ClerkOfTheCourt = ClerkOfTheCourt;

        var King = (function () {
            function King() {
            }
            King.prototype.IsAbleToResolveComplaint = function (complaint) {
                return true;
            };

            King.prototype.ListenToComplaint = function (complaint) {
                //perform some operation
                //return solution to the complaint
                return "";
            };
            return King;
        })();
        JudicialSystem.King = King;

        var ComplaintResolver = (function () {
            function ComplaintResolver() {
                this.complaintListeners = new Array();
                this.complaintListeners.push(new ClerkOfTheCourt());
                this.complaintListeners.push(new King());
            }
            ComplaintResolver.prototype.ResolveComplaint = function (complaint) {
                for (var i = 0; i < this.complaintListeners.length; i++) {
                    if (this.complaintListeners[i].IsAbleToResolveComplaint(complaint)) {
                        return this.complaintListeners[i].ListenToComplaint(complaint);
                    }
                }
            };
            return ComplaintResolver;
        })();
        JudicialSystem.ComplaintResolver = ComplaintResolver;
    })(Westeros.JudicialSystem || (Westeros.JudicialSystem = {}));
    var JudicialSystem = Westeros.JudicialSystem;
})(Westeros || (Westeros = {}));

* 명령(Command)패턴

- 명령(command) 패턴은 메소드의 매개변수와 객체의 현재 상태 모두를 캡슐화하고 메소드를 호출하는 방법임.
실제로 명령 패턴은 메소드를 나중에 호출할 때 필요한 것들을 작은 패키지로 포장함.
이 방법을 사용하면, 먼저 명령을 샐행하고 어떤 코드가 명령을 실행할지를 나중에 결정할 때까지 기다릴 수 있음.
이 패키지는 큐에 들어가거나 심지어 추후 실행을 위해 직렬화 될 수도 있음. 실행 취소 또는 명령 로깅 같은 기능 추가를 위한 명령 실행의 단일 지점을 갖는 것도 가능

var Westeros;
(function (Westeros) {
    (function (Communication) {
        var BringTroopsCommand = (function () {
            function BringTroopsCommand(location, numberOfTroops, when) {
                this._location = location;
                this._numberOfTroops = numberOfTroops;
                this._when = when;
            }
            BringTroopsCommand.prototype.Execute = function () {
                var receiver = new LordInstructions();
                receiver.BringTroops(this._location, this._numberOfTroops, this._when);
            };
            return BringTroopsCommand;
        })();
        Communication.BringTroopsCommand = BringTroopsCommand;

        var LordInstructions = (function () {
            function LordInstructions() {
            }
            LordInstructions.prototype.BringTroops = function (location, numberOfTroops, when) {
                console.log("You have been instructed to bring " + numberOfTroops + " troops to " + location + " by " + when);
            };
            return LordInstructions;
        })();
        Communication.LordInstructions = LordInstructions;

        var simpleCommand = new Array();
        simpleCommand.push(new LordInstructions().BringTroops);
        simpleCommand.push("King's Landing");
        simpleCommand.push(500);
        simpleCommand.push(new Date());

        simpleCommand[0](simpleCommand[1], simpleCommand[2], simpleCommand[3], simpleCommand[4], simpleCommand[5], simpleCommand[6]);
    })(Westeros.Communication || (Westeros.Communication = {}));
    var Communication = Westeros.Communication;
})(Westeros || (Westeros = {}));

* 해석자(Interpreter)패턴

- 자신만의 고유한 언어를 생성할 수 있게 해주는 재미있는 패텬임. 이패턴은 패턴에 의해 정의된 실제 클래스 구조가 없기 때문에 지금까지 살펴본
패턴들과 다름. 당신이 원하는 대로 언어 해석자를 디자인 할 수 있음

var Westeros;
(function (Westeros) {
    (function (History) {
        var Battle = (function () {
            function Battle(battleGround, agressor, defender, victor) {
                this.battleGround = battleGround;
                this.agressor = agressor;
                this.defender = defender;
                this.victor = victor;
            }
            return Battle;
        })();
        History.Battle = Battle;

        var Parser = (function () {
            function Parser(battleText) {
                this.battleText = battleText;
                this.currentIndex = 0;
                this.battleList = battleText.split("\n");
            }
            Parser.prototype.nextBattle = function () {
                if (!this.battleList[0])
                    return null;
                var segments = this.battleList[0].match(/\((.+?)\s?->\s?(.+?)\s?<-\s?(.+?)\s?->\s?(.+)/);
                return new Battle(segments[2], segments[1], segments[3], segments[4]);
            };
            return Parser;
        })();
        History.Parser = Parser;
    })(Westeros.History || (Westeros.History = {}));
    var History = Westeros.History;
})(Westeros || (Westeros = {}));