A short cheat-sheet with Xcode 10.2 Playground (Design-Patterns.playground.zip).
π· Project started by: @nsmeme (Oktawian Chojnacki)
π· δΈζηη± @binglogo (ζ£ζ£ε½¬) ζ΄ηηΏ»θ―γ
π How to generate README, Playground and zip from source: GENERATE.md
print("Welcome!")In software engineering, behavioral design patterns are design patterns that identify common communication patterns between objects and realize these patterns. By doing so, these patterns increase flexibility in carrying out this communication.
Source:wikipedia.org
The chain of responsibility pattern is used to process varied requests, each of which may be dealt with by a different handler.
protocolWithdrawing{func withdraw(amount:Int)->Bool}finalclassMoneyPile:Withdrawing{letvalue:Intvarquantity:Intvarnext:Withdrawing?init(value:Int, quantity:Int, next:Withdrawing?){self.value = value
self.quantity = quantity
self.next = next
}func withdraw(amount:Int)->Bool{varamount= amount
func canTakeSomeBill(want:Int)->Bool{return(want /self.value)>0}varquantity=self.quantity
whilecanTakeSomeBill(want: amount){if quantity ==0{break}
amount -=self.value
quantity -=1}guard amount >0else{returntrue}iflet next =self.next {return next.withdraw(amount: amount)}returnfalse}}finalclassATM:Withdrawing{privatevarhundred:Withdrawingprivatevarfifty:Withdrawingprivatevartwenty:Withdrawingprivatevarten:WithdrawingprivatevarstartPile:Withdrawing{returnself.hundred
}init(hundred:Withdrawing,
fifty:Withdrawing,
twenty:Withdrawing,
ten:Withdrawing){self.hundred = hundred
self.fifty = fifty
self.twenty = twenty
self.ten = ten
}func withdraw(amount:Int)->Bool{return startPile.withdraw(amount: amount)}}// Create piles of money and link them together 10 < 20 < 50 < 100.**
letten=MoneyPile(value:10, quantity:6, next:nil)lettwenty=MoneyPile(value:20, quantity:2, next: ten)letfifty=MoneyPile(value:50, quantity:2, next: twenty)lethundred=MoneyPile(value:100, quantity:1, next: fifty)
// Build ATM.
varatm=ATM(hundred: hundred, fifty: fifty, twenty: twenty, ten: ten)
atm.withdraw(amount:310) // Cannot because ATM has only 300
atm.withdraw(amount:100) // Can withdraw - 1x100The command pattern is used to express a request, including the call to be made and all of its required parameters, in a command object. The command may then be executed immediately or held for later use.
protocolDoorCommand{func execute()->String}finalclassOpenCommand:DoorCommand{letdoors:Stringrequiredinit(doors:String){self.doors = doors
}func execute()->String{return"Opened \(doors)"}}finalclassCloseCommand:DoorCommand{letdoors:Stringrequiredinit(doors:String){self.doors = doors
}func execute()->String{return"Closed \(doors)"}}finalclassHAL9000DoorsOperations{letopenCommand:DoorCommandletcloseCommand:DoorCommandinit(doors:String){self.openCommand =OpenCommand(doors:doors)self.closeCommand =CloseCommand(doors:doors)}func close()->String{return closeCommand.execute()}func open()->String{return openCommand.execute()}}letpodBayDoors="Pod Bay Doors"letdoorModule=HAL9000DoorsOperations(doors:podBayDoors)
doorModule.open()
doorModule.close()The interpreter pattern is used to evaluate sentences in a language.
protocolIntegerExpression{func evaluate(_ context:IntegerContext)->Intfunc replace(character:Character, integerExpression:IntegerExpression)->IntegerExpressionfunc copied()->IntegerExpression}finalclassIntegerContext{privatevardata:[Character:Int]=[:]func lookup(name:Character)->Int{returnself.data[name]!
}func assign(expression:IntegerVariableExpression, value:Int){self.data[expression.name]= value
}}finalclassIntegerVariableExpression:IntegerExpression{letname:Characterinit(name:Character){self.name = name
}func evaluate(_ context:IntegerContext)->Int{return context.lookup(name:self.name)}func replace(character name:Character, integerExpression:IntegerExpression)->IntegerExpression{if name ==self.name {return integerExpression.copied()}else{returnIntegerVariableExpression(name:self.name)}}func copied()->IntegerExpression{returnIntegerVariableExpression(name:self.name)}}finalclassAddExpression:IntegerExpression{privatevaroperand1:IntegerExpressionprivatevaroperand2:IntegerExpressioninit(op1:IntegerExpression, op2:IntegerExpression){self.operand1 = op1
self.operand2 = op2
}func evaluate(_ context:IntegerContext)->Int{returnself.operand1.evaluate(context)+self.operand2.evaluate(context)}func replace(character:Character, integerExpression:IntegerExpression)->IntegerExpression{returnAddExpression(op1: operand1.replace(character: character, integerExpression: integerExpression),
op2: operand2.replace(character: character, integerExpression: integerExpression))}func copied()->IntegerExpression{returnAddExpression(op1:self.operand1, op2:self.operand2)}}varcontext=IntegerContext()vara=IntegerVariableExpression(name:"A")varb=IntegerVariableExpression(name:"B")varc=IntegerVariableExpression(name:"C")varexpression=AddExpression(op1: a, op2:AddExpression(op1: b, op2: c)) // a + (b + c)
context.assign(expression: a, value:2)
context.assign(expression: b, value:1)
context.assign(expression: c, value:3)varresult= expression.evaluate(context)The iterator pattern is used to provide a standard interface for traversing a collection of items in an aggregate object without the need to understand its underlying structure.
structNovella{letname:String}structNovellas{letnovellas:[Novella]}structNovellasIterator:IteratorProtocol{privatevarcurrent=0privateletnovellas:[Novella]init(novellas:[Novella]){self.novellas = novellas
}mutatingfunc next()->Novella?{defer{ current +=1}return novellas.count > current ?novellas[current]:nil}}extensionNovellas:Sequence{func makeIterator()->NovellasIterator{returnNovellasIterator(novellas: novellas)}}letgreatNovellas=Novellas(novellas:[Novella(name:"The Mist")])fornovellain greatNovellas {print("I've read: \(novella)")}The mediator pattern is used to reduce coupling between classes that communicate with each other. Instead of classes communicating directly, and thus requiring knowledge of their implementation, the classes send messages via a mediator object.
protocolReceiver{associatedtypeMessageTypefunc receive(message:MessageType)}protocolSender{associatedtypeMessageTypeassociatedtypeReceiverType:Receivervarrecipients:[ReceiverType]{get}func send(message:MessageType)}structProgrammer:Receiver{letname:Stringinit(name:String){self.name = name
}func receive(message:String){print("\(name) received: \(message)")}}finalclassMessageMediator:Sender{internalvarrecipients:[Programmer]=[]func add(recipient:Programmer){
recipients.append(recipient)}func send(message:String){forrecipientin recipients {
recipient.receive(message: message)}}}func spamMonster(message:String, worker:MessageMediator){
worker.send(message: message)}letmessagesMediator=MessageMediator()letuser0=Programmer(name:"Linus Torvalds")letuser1=Programmer(name:"Avadis 'Avie' Tevanian")
messagesMediator.add(recipient: user0)
messagesMediator.add(recipient: user1)spamMonster(message:"I'd Like to Add you to My Professional Network", worker: messagesMediator)The memento pattern is used to capture the current state of an object and store it in such a manner that it can be restored at a later time without breaking the rules of encapsulation.
typealiasMemento=[String:String]Originator
protocolMementoConvertible{varmemento:Memento{get}init?(memento:Memento)}structGameState:MementoConvertible{privateenumKeys{staticletchapter="com.valve.halflife.chapter"staticletweapon="com.valve.halflife.weapon"}varchapter:Stringvarweapon:Stringinit(chapter:String, weapon:String){self.chapter = chapter
self.weapon = weapon
}init?(memento:Memento){guardlet mementoChapter =memento[Keys.chapter],let mementoWeapon =memento[Keys.weapon]else{returnnil}
chapter = mementoChapter
weapon = mementoWeapon
}varmemento:Memento{return[Keys.chapter: chapter,Keys.weapon: weapon ]}}Caretaker
enumCheckPoint{privatestaticletdefaults=UserDefaults.standard
staticfunc save(_ state:MementoConvertible, saveName:String){
defaults.set(state.memento, forKey: saveName)
defaults.synchronize()}staticfunc restore(saveName:String)->Any?{return defaults.object(forKey: saveName)}}vargameState=GameState(chapter:"Black Mesa Inbound", weapon:"Crowbar")
gameState.chapter ="Anomalous Materials"
gameState.weapon ="Glock 17"CheckPoint.save(gameState, saveName:"gameState1")
gameState.chapter ="Unforeseen Consequences"
gameState.weapon ="MP5"CheckPoint.save(gameState, saveName:"gameState2")
gameState.chapter ="Office Complex"
gameState.weapon ="Crossbow"CheckPoint.save(gameState, saveName:"gameState3")iflet memento =CheckPoint.restore(saveName:"gameState1")as?Memento{letfinalState=GameState(memento: memento)dump(finalState)}The observer pattern is used to allow an object to publish changes to its state. Other objects subscribe to be immediately notified of any changes.
protocolPropertyObserver:class{func willChange(propertyName:String, newPropertyValue:Any?)func didChange(propertyName:String, oldPropertyValue:Any?)}finalclassTestChambers{
weak varobserver:PropertyObserver?privatelettestChamberNumberName="testChamberNumber"vartestChamberNumber:Int=0{
willSet(newValue){
observer?.willChange(propertyName: testChamberNumberName, newPropertyValue: newValue)}
didSet {
observer?.didChange(propertyName: testChamberNumberName, oldPropertyValue: oldValue)}}}finalclassObserver:PropertyObserver{func willChange(propertyName:String, newPropertyValue:Any?){if newPropertyValue as?Int==1{print("Okay. Look. We both said a lot of things that you're going to regret.")}}func didChange(propertyName:String, oldPropertyValue:Any?){if oldPropertyValue as?Int==0{print("Sorry about the mess. I've really let the place go since you killed me.")}}}varobserverInstance=Observer()vartestChambers=TestChambers()
testChambers.observer = observerInstance
testChambers.testChamberNumber +=1The state pattern is used to alter the behaviour of an object as its internal state changes. The pattern allows the class for an object to apparently change at run-time.
finalclassContext{privatevarstate:State=UnauthorizedState()varisAuthorized:Bool{get{return state.isAuthorized(context:self)}}varuserId:String?{get{return state.userId(context:self)}}func changeStateToAuthorized(userId:String){
state =AuthorizedState(userId: userId)}func changeStateToUnauthorized(){
state =UnauthorizedState()}}protocolState{func isAuthorized(context:Context)->Boolfunc userId(context:Context)->String?}classUnauthorizedState:State{func isAuthorized(context:Context)->Bool{returnfalse}func userId(context:Context)->String?{returnnil}}classAuthorizedState:State{letuserId:Stringinit(userId:String){self.userId = userId }func isAuthorized(context:Context)->Bool{returntrue}func userId(context:Context)->String?{return userId }}letuserContext=Context()(userContext.isAuthorized, userContext.userId)
userContext.changeStateToAuthorized(userId:"admin")(userContext.isAuthorized, userContext.userId) // now logged in as "admin"
userContext.changeStateToUnauthorized()(userContext.isAuthorized, userContext.userId)The strategy pattern is used to create an interchangeable family of algorithms from which the required process is chosen at run-time.
structTestSubject{letpupilDiameter:DoubleletblushResponse:DoubleletisOrganic:Bool}protocolRealnessTesting:AnyObject{func testRealness(_ testSubject:TestSubject)->Bool}finalclassVoightKampffTest:RealnessTesting{func testRealness(_ testSubject:TestSubject)->Bool{return testSubject.pupilDiameter <30.0 || testSubject.blushResponse ==0.0}}finalclassGeneticTest:RealnessTesting{func testRealness(_ testSubject:TestSubject)->Bool{return testSubject.isOrganic
}}finalclassBladeRunner{privateletstrategy:RealnessTestinginit(test:RealnessTesting){self.strategy = test
}func testIfAndroid(_ testSubject:TestSubject)->Bool{return !strategy.testRealness(testSubject)}}letrachel=TestSubject(pupilDiameter:30.2,
blushResponse:0.3,
isOrganic:false)
// Deckard is using a traditional test
letdeckard=BladeRunner(test:VoightKampffTest())letisRachelAndroid= deckard.testIfAndroid(rachel)
// Gaff is using a very precise method
letgaff=BladeRunner(test:GeneticTest())letisDeckardAndroid= gaff.testIfAndroid(rachel)The template method pattern defines the steps of an algorithm and allows the redefinition of one or more of these steps. In this way, the template method protects the algorithm, the order of execution and provides abstract methods that can be implemented by concrete types.
protocolGarden{func prepareSoil()func plantSeeds()func waterPlants()func prepareGarden()}extensionGarden{func prepareGarden(){prepareSoil()plantSeeds()waterPlants()}}finalclassRoseGarden:Garden{func prepare(){prepareGarden()}func prepareSoil(){print("prepare soil for rose garden")}func plantSeeds(){print("plant seeds for rose garden")}func waterPlants(){print("water the rose garden")}}letroseGarden=RoseGarden()
roseGarden.prepare()The visitor pattern is used to separate a relatively complex set of structured data classes from the functionality that may be performed upon the data that they hold.
protocolPlanetVisitor{func visit(planet:PlanetAlderaan)func visit(planet:PlanetCoruscant)func visit(planet:PlanetTatooine)func visit(planet:MoonJedha)}protocolPlanet{func accept(visitor:PlanetVisitor)}finalclassMoonJedha:Planet{func accept(visitor:PlanetVisitor){ visitor.visit(planet:self)}}finalclassPlanetAlderaan:Planet{func accept(visitor:PlanetVisitor){ visitor.visit(planet:self)}}finalclassPlanetCoruscant:Planet{func accept(visitor:PlanetVisitor){ visitor.visit(planet:self)}}finalclassPlanetTatooine:Planet{func accept(visitor:PlanetVisitor){ visitor.visit(planet:self)}}finalclassNameVisitor:PlanetVisitor{varname=""func visit(planet:PlanetAlderaan){ name ="Alderaan"}func visit(planet:PlanetCoruscant){ name ="Coruscant"}func visit(planet:PlanetTatooine){ name ="Tatooine"}func visit(planet:MoonJedha){ name ="Jedha"}}letplanets:[Planet]=[PlanetAlderaan(),PlanetCoruscant(),PlanetTatooine(),MoonJedha()]letnames= planets.map{(planet:Planet)->Stringinletvisitor=NameVisitor()
planet.accept(visitor: visitor)return visitor.name
}
namesIn software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation.
Source:wikipedia.org
The abstract factory pattern is used to provide a client with a set of related or dependant objects. The "family" of objects created by the factory are determined at run-time.
Protocols
protocolBurgerDescribing{varingredients:[String]{get}}structCheeseBurger:BurgerDescribing{letingredients:[String]}protocolBurgerMaking{func make()->BurgerDescribing}
// Number implementations with factory methods
finalclassBigKahunaBurger:BurgerMaking{func make()->BurgerDescribing{returnCheeseBurger(ingredients:["Cheese","Burger","Lettuce","Tomato"])}}finalclassJackInTheBox:BurgerMaking{func make()->BurgerDescribing{returnCheeseBurger(ingredients:["Cheese","Burger","Tomato","Onions"])}}Abstract factory
enumBurgerFactoryType:BurgerMaking{case bigKahuna
case jackInTheBox
func make()->BurgerDescribing{switchself{case.bigKahuna:returnBigKahunaBurger().make()case.jackInTheBox:returnJackInTheBox().make()}}}letbigKahuna=BurgerFactoryType.bigKahuna.make()letjackInTheBox=BurgerFactoryType.jackInTheBox.make()The builder pattern is used to create complex objects with constituent parts that must be created in the same order or using a specific algorithm. An external class controls the construction algorithm.
finalclassDeathStarBuilder{varx:Double?vary:Double?varz:Double?typealiasBuilderClosure=(DeathStarBuilder)->()init(buildClosure:BuilderClosure){buildClosure(self)}}structDeathStar:CustomStringConvertible{letx:Doublelety:Doubleletz:Doubleinit?(builder:DeathStarBuilder){iflet x = builder.x,let y = builder.y,let z = builder.z {self.x = x
self.y = y
self.z = z
}else{returnnil}}vardescription:String{return"Death Star at (x:\(x) y:\(y) z:\(z))"}}letempire=DeathStarBuilder{ builder in
builder.x =0.1
builder.y =0.2
builder.z =0.3}letdeathStar=DeathStar(builder:empire)The factory pattern is used to replace class constructors, abstracting the process of object generation so that the type of the object instantiated can be determined at run-time.
protocolCurrencyDescribing{varsymbol:String{get}varcode:String{get}}finalclassEuro:CurrencyDescribing{varsymbol:String{return"β¬"}varcode:String{return"EUR"}}finalclassUnitedStatesDolar:CurrencyDescribing{varsymbol:String{return"$"}varcode:String{return"USD"}}enumCountry{case unitedStates
case spain
case uk
case greece
}enumCurrencyFactory{staticfunc currency(for country:Country)->CurrencyDescribing?{switch country {case.spain,.greece:returnEuro()case.unitedStates:returnUnitedStatesDolar()default:returnnil}}}letnoCurrencyCode="No Currency Code Available"CurrencyFactory.currency(for:.greece)?.code ?? noCurrencyCode
CurrencyFactory.currency(for:.spain)?.code ?? noCurrencyCode
CurrencyFactory.currency(for:.unitedStates)?.code ?? noCurrencyCode
CurrencyFactory.currency(for:.uk)?.code ?? noCurrencyCodeThe monostate pattern is another way to achieve singularity. It works through a completely different mechanism, it enforces the behavior of singularity without imposing structural constraints. So in that case, monostate saves the state as static instead of the entire instance as a singleton. SINGLETON and MONOSTATE - Robert C. Martin
struct Settings {enum Theme {
case .old
case .new
}privatestaticvartheme:ThemevarcurrentTheme:Theme{get{Settings.theme }set(newTheme){Settings.theme = newTheme }}}// When change the theme
letsettings=Settings() // Starts using theme .old
settings.currentTheme =.new // Change theme to .new
//On screen 1
letscreenColor:Color=Settings().currentTheme ==.old ?.gray :.white
//On screen 2
letscreenTitle:String=Settings().currentTheme ==.old ?"Itunes Connect":"App Store Connect"The prototype pattern is used to instantiate a new object by copying all of the properties of an existing object, creating an independent clone. This practise is particularly useful when the construction of a new object is inefficient.
structMoonWorker{letname:Stringvarhealth:Int=100init(name:String){self.name = name
}func clone()->MoonWorker{returnMoonWorker(name: name)}}letprototype=MoonWorker(name:"Sam Bell")varbell1= prototype.clone()
bell1.health =12varbell2= prototype.clone()
bell2.health =23varbell3= prototype.clone()
bell3.health =0The singleton pattern ensures that only one object of a particular class is ever created. All further references to objects of the singleton class refer to the same underlying instance. There are very few applications, do not overuse this pattern!
finalclassElonMusk{staticletshared=ElonMusk()privateinit(){
// Private initialization to ensure just one instance is created.
}}letelon=ElonMusk.shared // There is only one Elon Musk folks.In software engineering, structural design patterns are design patterns that ease the design by identifying a simple way to realize relationships between entities.
Source:wikipedia.org
The adapter pattern is used to provide a link between two otherwise incompatible types by wrapping the "adaptee" with a class that supports the interface required by the client.
protocolNewDeathStarSuperLaserAiming{varangleV:Double{get}varangleH:Double{get}}Adaptee
structOldDeathStarSuperlaserTarget{letangleHorizontal:FloatletangleVertical:Floatinit(angleHorizontal:Float, angleVertical:Float){self.angleHorizontal = angleHorizontal
self.angleVertical = angleVertical
}}Adapter
structNewDeathStarSuperlaserTarget:NewDeathStarSuperLaserAiming{privatelettarget:OldDeathStarSuperlaserTargetvarangleV:Double{returnDouble(target.angleVertical)}varangleH:Double{returnDouble(target.angleHorizontal)}init(_ target:OldDeathStarSuperlaserTarget){self.target = target
}}lettarget=OldDeathStarSuperlaserTarget(angleHorizontal:14.0, angleVertical:12.0)letnewFormat=NewDeathStarSuperlaserTarget(target)
newFormat.angleH
newFormat.angleVThe bridge pattern is used to separate the abstract elements of a class from the implementation details, providing the means to replace the implementation details without modifying the abstraction.
protocolSwitch{varappliance:Appliance{getset}func turnOn()}protocolAppliance{func run()}finalclassRemoteControl:Switch{varappliance:Appliancefunc turnOn(){self.appliance.run()}init(appliance:Appliance){self.appliance = appliance
}}finalclassTV:Appliance{func run(){print("tv turned on");
}}finalclassVacuumCleaner:Appliance{func run(){print("vacuum cleaner turned on")}}lettvRemoteControl=RemoteControl(appliance:TV())
tvRemoteControl.turnOn()letfancyVacuumCleanerRemoteControl=RemoteControl(appliance:VacuumCleaner())
fancyVacuumCleanerRemoteControl.turnOn()The composite pattern is used to create hierarchical, recursive tree structures of related objects where any element of the structure may be accessed and utilised in a standard manner.
Component
protocolShape{func draw(fillColor:String)}Leafs
finalclassSquare:Shape{func draw(fillColor:String){print("Drawing a Square with color \(fillColor)")}}finalclassCircle:Shape{func draw(fillColor:String){print("Drawing a circle with color \(fillColor)")}}Composite
finalclassWhiteboard:Shape{private lazy varshapes=[Shape]()init(_ shapes:Shape...){self.shapes = shapes
}func draw(fillColor:String){forshapeinself.shapes {
shape.draw(fillColor: fillColor)}}}varwhiteboard=Whiteboard(Circle(),Square())
whiteboard.draw(fillColor:"Red")The decorator pattern is used to extend or alter the functionality of objects at run- time by wrapping them in an object of a decorator class. This provides a flexible alternative to using inheritance to modify behaviour.
protocolCostHaving{varcost:Double{get}}protocolIngredientsHaving{varingredients:[String]{get}}typealiasBeverageDataHaving=CostHaving&IngredientsHavingstructSimpleCoffee:BeverageDataHaving{letcost:Double=1.0letingredients=["Water","Coffee"]}protocolBeverageHaving:BeverageDataHaving{varbeverage:BeverageDataHaving{get}}structMilk:BeverageHaving{letbeverage:BeverageDataHavingvarcost:Double{return beverage.cost +0.5}varingredients:[String]{return beverage.ingredients +["Milk"]}}structWhipCoffee:BeverageHaving{letbeverage:BeverageDataHavingvarcost:Double{return beverage.cost +0.5}varingredients:[String]{return beverage.ingredients +["Whip"]}}varsomeCoffee:BeverageDataHaving=SimpleCoffee()print("Cost: \(someCoffee.cost); Ingredients: \(someCoffee.ingredients)")
someCoffee =Milk(beverage: someCoffee)print("Cost: \(someCoffee.cost); Ingredients: \(someCoffee.ingredients)")
someCoffee =WhipCoffee(beverage: someCoffee)print("Cost: \(someCoffee.cost); Ingredients: \(someCoffee.ingredients)")The facade pattern is used to define a simplified interface to a more complex subsystem.
finalclassDefaults{privateletdefaults:UserDefaultsinit(defaults:UserDefaults=.standard){self.defaults = defaults
}
subscript(key:String)->String?{get{return defaults.string(forKey: key)}set{
defaults.set(newValue, forKey: key)}}}letstorage=Defaults()
// Store
storage["Bishop"]="Disconnect me. Iβd rather be nothing"
// Read
storage["Bishop"]The flyweight pattern is used to minimize memory usage or computational expenses by sharing as much as possible with other similar objects.
// Instances of SpecialityCoffee will be the Flyweights
structSpecialityCoffee{letorigin:String}protocolCoffeeSearching{func search(origin:String)->SpecialityCoffee?}
// Menu acts as a factory and cache for SpecialityCoffee flyweight objects
finalclassMenu:CoffeeSearching{privatevarcoffeeAvailable:[String:SpecialityCoffee]=[:]func search(origin:String)->SpecialityCoffee?{if coffeeAvailable.index(forKey: origin)==nil{coffeeAvailable[origin]=SpecialityCoffee(origin: origin)}returncoffeeAvailable[origin]}}finalclassCoffeeShop{privatevarorders:[Int:SpecialityCoffee]=[:]privateletmenu:CoffeeSearchinginit(menu:CoffeeSearching){self.menu = menu
}func takeOrder(origin:String, table:Int){orders[table]= menu.search(origin: origin)}func serve(){for(table, origin)in orders {print("Serving \(origin) to table \(table)")}}}letcoffeeShop=CoffeeShop(menu:Menu())
coffeeShop.takeOrder(origin:"Yirgacheffe, Ethiopia", table:1)
coffeeShop.takeOrder(origin:"Buziraguhindwa, Burundi", table:3)
coffeeShop.serve()The proxy pattern is used to provide a surrogate or placeholder object, which references an underlying object. Protection proxy is restricting access.
protocolDoorOpening{func open(doors:String)->String}finalclassHAL9000:DoorOpening{func open(doors:String)->String{return("HAL9000: Affirmative, Dave. I read you. Opened \(doors).")}}finalclassCurrentComputer:DoorOpening{privatevarcomputer:HAL9000!func authenticate(password:String)->Bool{guard password =="pass"else{returnfalse}
computer =HAL9000()returntrue}func open(doors:String)->String{guard computer !=nilelse{return"Access Denied. I'm afraid I can't do that."}return computer.open(doors: doors)}}letcomputer=CurrentComputer()letpodBay="Pod Bay Doors"
computer.open(doors: podBay)
computer.authenticate(password:"pass")
computer.open(doors: podBay)The proxy pattern is used to provide a surrogate or placeholder object, which references an underlying object. Virtual proxy is used for loading object on demand.
protocolHEVSuitMedicalAid{func administerMorphine()->String}finalclassHEVSuit:HEVSuitMedicalAid{func administerMorphine()->String{return"Morphine administered."}}finalclassHEVSuitHumanInterface:HEVSuitMedicalAid{
lazy privatevarphysicalSuit:HEVSuit=HEVSuit()func administerMorphine()->String{return physicalSuit.administerMorphine()}}lethumanInterface=HEVSuitHumanInterface()
humanInterface.administerMorphine()π Descriptions from: Gang of Four Design Patterns Reference Sheet