Swift 2.0 and Xcode 7beta update!

Author: Oktawian Chojnacki

Design-Patterns.playground.zip

@@ -0,0 +1,255 @@
+//: [Behavioral](Behavioral) |
+//: Creational |
+//: [Structural](Structural)
+/*:
+Creational
+==========
+
+> In 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](http://en.wikipedia.org/wiki/Creational_pattern)
+*/
+import Swift
+import Foundation/*:
+🌰 Abstract Factory
+-------------------
+
+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.
+
+### Example
+*/
+/*:
+Protocols
+*/
+protocol Decimal {
+    func stringValue() -> String
+}
+
+protocol NumberFactoryProtocol {
+    func numberFromString(string : String) -> Decimal
+}
+
+// Number implementations
+
+struct NextStepNumber : Decimal {
+    private var nextStepNumber : NSNumber
+
+    func stringValue() -> String { return nextStepNumber.stringValue }
+}
+
+struct SwiftNumber : Decimal {
+    private var swiftInt : Int
+
+    func stringValue() -> String { return "\(swiftInt)" }
+}
+/*:
+Factories
+*/
+class NextStepNumberFactory : NumberFactoryProtocol {
+    func numberFromString(string : String) -> Decimal {
+        return NextStepNumber(nextStepNumber:NSNumber(longLong:(string as NSString).longLongValue))
+    }
+}
+
+class SwiftNumberFactory : NumberFactoryProtocol {
+    func numberFromString(string : String) -> Decimal {
+        return SwiftNumber(swiftInt:(string as NSString).integerValue)
+    }
+}
+/*:
+Abstract factory
+*/
+enum NumberType {
+    case NextStep, Swift
+}
+
+class NumberAbstractFactory {
+    class func numberFactoryType(type : NumberType) -> NumberFactoryProtocol {
+
+        switch type {
+            case .NextStep:
+                    return NextStepNumberFactory()
+            case .Swift:
+                    return SwiftNumberFactory()
+        }
+    }
+}
+/*:
+### Usage
+*/
+let factoryOne = NumberAbstractFactory.numberFactoryType(.NextStep)
+let numberOne = factoryOne.numberFromString("1")
+numberOne.stringValue()
+
+let factoryTwo = NumberAbstractFactory.numberFactoryType(.Swift)
+let numberTwo = factoryTwo.numberFromString("2")
+numberTwo.stringValue()
+/*:
+👷 Builder
+----------
+
+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.
+
+### Example
+*/
+class DeathStarBuilder {
+
+    var x: Double?
+    var y: Double?
+    var z: Double?
+
+    typealias BuilderClosure = (DeathStarBuilder) -> ()
+
+    init(buildClosure: BuilderClosure) {
+        buildClosure(self)
+    }
+}
+
+struct DeathStar : CustomStringConvertible {
+
+    let x: Double
+    let y: Double
+    let z: Double
+
+    init?(builder: DeathStarBuilder) {
+
+        if let x = builder.x, y = builder.y, z = builder.z {
+            self.x = x
+            self.y = y
+            self.z = z
+        } else {
+            return nil
+        }
+    }
+
+    var description:String {
+        return "Death Star at (x:\(x) y:\(y) z:\(z))"
+    }
+}
+/*:
+### Usage
+*/
+let empire = DeathStarBuilder { builder in
+    builder.x = 0.1
+    builder.y = 0.2
+    builder.z = 0.3
+}
+
+let deathStar = DeathStar(builder:empire)
+/*:
+🏭 Factory Method
+-----------------
+
+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.
+
+### Example
+*/
+protocol Currency {
+    func symbol() -> String
+    func code() -> String
+}
+
+class Euro : Currency {
+    func symbol() -> String {
+        return "€"
+    }
+
+    func code() -> String {
+        return "EUR"
+    }
+}
+
+class UnitedStatesDolar : Currency {
+    func symbol() -> String {
+        return "$"
+    }
+
+    func code() -> String {
+        return "USD"
+    }
+}
+
+enum Country {
+    case UnitedStates, Spain, UK, Greece
+}
+
+class CurrencyFactory {
+    class func currencyForCountry(country:Country) -> Currency? {
+
+        switch country {
+            case .Spain, .Greece :
+                return Euro()
+            case .UnitedStates :
+                return UnitedStatesDolar()
+            default:
+                return nil
+        }
+
+    }
+}
+/*:
+### Usage
+*/
+let noCurrencyCode = "No Currency Code Available"
+
+CurrencyFactory.currencyForCountry(.Greece)?.code() ?? noCurrencyCode
+CurrencyFactory.currencyForCountry(.Spain)?.code() ?? noCurrencyCode
+CurrencyFactory.currencyForCountry(.UnitedStates)?.code() ?? noCurrencyCode
+CurrencyFactory.currencyForCountry(.UK)?.code() ?? noCurrencyCode
+/*:
+🃏 Prototype
+------------
+
+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.
+
+### Example
+*/
+class ChungasRevengeDisplay {
+    var name: String?
+    let font: String
+
+    init(font: String) {
+        self.font = font
+    }
+
+    func clone() -> ChungasRevengeDisplay {
+        return ChungasRevengeDisplay(font:self.font)
+    }
+}
+/*:
+### Usage
+*/
+let Prototype = ChungasRevengeDisplay(font:"GotanProject")
+
+let Philippe = Prototype.clone()
+Philippe.name = "Philippe"
+
+let Christoph = Prototype.clone()
+Christoph.name = "Christoph"
+
+let Eduardo = Prototype.clone()
+Eduardo.name = "Eduardo"
+/*:
+💍 Singleton
+------------
+
+The 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!
+
+### Example:
+*/
+class DeathStarSuperlaser {
+    static let sharedInstance = DeathStarSuperlaser()
+
+    private init() {
+        // Private initialization to ensure just one instance is created.
+    }
+}
+/*:
+### Usage:
+*/
+let laser = DeathStarSuperlaser.sharedInstance

Design-Patterns.playground/Pages/Behavioral.xcplaygroundpage/Contents.swift

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Timeline
+   version = "3.0">
+   <TimelineItems>
+   </TimelineItems>
+</Timeline>