added remaining patterns

Author: codersanjeev

README.md

@@ -0,0 +1,34 @@
+
+class Node<T> {
+	let value: T
+	var left: Node<T>? = nil
+	var right: Node<T>? = nil
+	var parent: Node<T>? = nil
+	
+	init(_ value: T) {
+		self.value = value
+	}
+	
+	init(_ value: T, _ left: Node<T>, _ right: Node<T>) {
+		self.value = value
+		self.left = left
+		self.right = right
+		self.left?.parent = self
+		self.right?.parent = self
+	}
+	
+	private func preorder(_ node: Node<T>?) -> [T] {
+		if let node = node {
+			var ans = [node.value]
+			ans += preorder(node.left)
+			ans += preorder(node.right)
+			return ans
+		} else {
+			return []
+		}
+	}
+	
+	public var preOrder: [T] {
+		return preorder(self)
+	}
+}

iterator/exercise.swift

@@ -0,0 +1,68 @@
+import Foundation
+
+class Node<T> {
+	var value: T
+	var left: Node<T>? = nil
+	var right: Node<T>? = nil
+	var parent: Node<T>? = nil
+	
+	init(_ value: T) {
+		self.value = value
+	}
+	
+	init(_ value: T, left: Node<T>, right: Node<T>) {
+		self.value = value
+		self.left = left
+		self.right = right
+		self.left?.parent = self
+		self.right?.parent = self
+	}
+}
+
+class Inorderterator<T>: IteratorProtocol {
+	var current: Node<T>?
+	var root: Node<T>
+	var yieldedStart = false
+	
+	init(_ root: Node<T>) {
+		self.root = root
+		self.current = root
+		while current?.left != nil {
+			current = current?.left
+		}
+	}
+	
+	func next() -> Node<T>? {
+		if !yieldedStart {
+			yieldedStart = true
+			return current
+		} else {
+			if current?.right != nil  {
+				current = current?.right
+				while current?.left != nil {
+					current = current?.left
+				}
+				return current
+			} else {
+				var parent = current?.parent
+				while parent != nil && current === parent?.right {
+					current = parent
+					parent = parent?.parent
+				}
+				current = parent
+				return current
+			}
+		}
+	}
+	
+	func reset() {
+		current = root
+		yieldedStart = false
+	}
+}
+
+let root = Node(1, left: Node(2), right: Node(3))
+let iterator = Inorderterator(root)
+while let element = iterator.next() {
+	debugPrint(element.value, terminator: " ")
+}

iterator/iterator.swift

@@ -0,0 +1,57 @@
+import Foundation
+
+class Person {
+	var name: String
+	var room: ChatRoom? = nil
+	private var chatLogs = [String]()
+	
+	init(_ name: String) {
+		self.name = name
+	}
+	
+	func receive(_ sender: String, message: String) {
+		print("[\(name)'s chat session] \(sender): `\(message)`")
+		chatLogs.append("\(sender): `\(message)`")
+	}
+	
+	func say(_ message: String) {
+		room?.broadcast(name, message: message)
+	}
+	
+	func privateMessage(_ receiver: String, message: String) {
+		room?.message(name, receiver, message)
+	}
+}
+
+class ChatRoom {
+	private var people = [Person]()
+	
+	func broadcast(_ sender: String, message: String) {
+		for person in people {
+			if person.name != sender {
+				person.receive(sender, message: message)
+			}
+		}
+	}
+	
+	func join(_ person: Person) {
+		broadcast("admin", message: "\(person.name) joined the chat")
+		person.room = self
+		people.append(person)
+	}
+	
+	func message(_ sender: String, _ receiver: String, _ message: String) {
+		people.first(where: { $0.name == receiver })?.receive(sender, message: message)
+	}
+}
+
+let room = ChatRoom()
+let john = Person("John")
+let doe = Person("Doe")
+room.join(john)
+room.join(doe)
+john.say("Hi!")
+doe.say("Hello!")
+let martin = Person("Martin")
+room.join(martin)
+martin.say("Hii!")

mediator/chatroom.swift

@@ -0,0 +1,25 @@
+class Participant {
+	private let mediator: Mediator
+	var value = 0
+	
+	init(_ mediator: Mediator) {
+		self.mediator = mediator
+		Mediator.participants.append(self)
+	}
+	
+	func say(_ n: Int) {
+		mediator.broadcast(from: self, n)
+	}
+}
+
+class Mediator {
+	static var participants = [Participant]()
+	
+	func broadcast(from participant: Participant, _ value: Int) {
+		for receiver in type(of: self).participants {
+			if receiver !== participant {
+				receiver.value += value
+			}
+		}
+	}
+}

mediator/exercise.swift

@@ -0,0 +1,77 @@
+import Foundation
+
+class Memento {
+	let balance: Int
+	
+	init(_ balance: Int) {
+		self.balance = balance
+	}
+}
+
+class BankAccount: CustomStringConvertible {
+	private var balance: Int
+	private var changes = [Memento]()
+	private var current = 0
+	
+	init(_ balance: Int) {
+		self.balance = balance
+		changes.append(Memento(balance))
+	}
+	
+	func deposit(_ amount: Int) -> Memento {
+		balance += amount
+		let memento = Memento(balance)
+		changes.append(memento)
+		current += 1
+		return memento
+	}
+	
+	func restore(_ memento: Memento?) {
+		if let memento = memento {
+			balance = memento.balance
+			changes.append(memento)
+			current = changes.count - 1
+		}
+	}
+	
+	func undo() -> Memento? {
+		guard current > 0 else { return nil }
+		current -= 1
+		let memento = changes[current]
+		balance = memento.balance
+		return memento
+	}
+	
+	func redo() -> Memento? {
+		guard current + 1 < changes.count else { return nil }
+		current += 1
+		let memento = changes[current]
+		balance = memento.balance
+		return memento
+	}
+	
+	var description: String {
+		return "Balance = \(balance)"
+	}
+}
+
+var account = BankAccount(100)
+let m1 = account.deposit(50)
+let m2 = account.deposit(25)
+//print(account)
+//
+//// restore
+//account.restore(m1)
+//print(account)
+//
+//account.restore(m2)
+//print(account)
+
+account.undo()
+print("Undo One: \(account)")
+
+account.undo()
+print("Undo Two: \(account)")
+
+account.redo()
+print("Redo One: \(account)")

memento/bankaccount.swift

@@ -0,0 +1,38 @@
+import Foundation
+import XCTest
+
+class Token {
+	var value = 0
+	init(_ value: Int) {
+		self.value = value
+	}
+	static func ==(_ lhs: Token, _ rhs: Token) -> Bool {
+		return lhs.value == rhs.value
+	}
+}
+
+class Memento {
+	var tokens = [Token]()
+}
+
+class TokenMachine {
+	var tokens = [Token]()
+	
+	func addToken(_ value: Int) -> Memento {
+		tokens.append(Token(value))
+		let memento = Memento()
+		memento.tokens = tokens
+		return memento
+	}
+	
+	func addToken(_ token: Token) -> Memento {
+		tokens.append(token)
+		let memento = Memento()
+		memento.tokens = tokens
+		return memento
+	}
+	
+	func revert(to memento: Memento) {
+		self.tokens = memento.tokens
+	}
+}

memento/exercise.swift

@@ -0,0 +1,39 @@
+import Foundation
+
+protocol Log {
+	func info(_ message: String)
+	func warn(_ message: String)
+}
+
+class ConsoleLog: Log {
+	func info(_ message: String) {
+		print("Information: \(message)")
+	}
+	
+	func warn(_ message: String) {
+		print("Warning: \(message)")
+	}
+}
+
+class NullLog: Log {
+	func info(_ message: String) {}
+	func warn(_ message: String) {}
+}
+
+class BankAccount {
+	var log: Log
+	var balance = 0
+	
+	init(_ log: Log) {
+		self.log = log
+	}
+	
+	func deposit(_ amount: Int) {
+		balance += amount
+		log.info("Deposited \(amount), Balance \(balance)")
+	}
+}
+
+let log = NullLog()
+let account = BankAccount(log)
+account.deposit(100)

nullobject/nulllog.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+protocol Invocalble: AnyObject {
+	func invoke(_ data: Any)
+}
+
+protocol Disposable {
+	func dispose()
+}
+
+class Subscription<T: AnyObject, U>: Invocalble, Disposable {
+	weak var target: T? = nil
+	let handler: (T) -> (U) -> ()
+	let event: Event<U>
+	
+	init(_ target: T?, handler: @escaping (T) -> (U) -> (), event: Event<U>) {
+		self.target = target
+		self.handler = handler
+		self.event = event
+	}
+	
+	func invoke(_ data: Any) {
+		if let target = target, let data = data as? U {
+			handler(target)(data)
+		}
+	}
+	
+	func dispose() {
+		event.eventHandlers = event.eventHandlers.filter {
+			$0 as AnyObject? !== self
+		}
+	}
+}
+
+class Event<T> {
+	typealias EventHandler = (T) -> ()
+	var eventHandlers = [Invocalble]()
+	
+	func raise(_ data: T) {
+		eventHandlers.forEach {
+			$0.invoke(data)
+		}
+	}
+	
+	func addHandler<U: AnyObject>(
+		target: U,
+		handler: @escaping (U) -> EventHandler
+	) -> Disposable {
+		return Subscription(target, handler: handler, event: self)
+	}
+}