// 协议 定义了一个蓝图, 规定了用来实现某一特定任务或者功能的方法, 属性, 以及其他需要的东西. 

// 类, 结构体, 或 枚举都可以遵循协议, 并且为协议定义的这些要求 提供具体的实现, 某个类型能够满足某个协议的要求, 就可以说该类型 遵循了这个协议

// 除了遵循协议的类型必须实现的要求外, 还可以对协议进行扩展, 通过扩展来实现一部分或者实现一些附加功能, 这样遵循的协议的类型能够使用这些功能

// 协议的语法

// 协议的定义方式 与 类, 结构体 和 枚举的定义非常相似

// protocol SomeProtocol{

//     // 这里是协议的定义部分

// }

//要让自定义类型遵循某个协议, 在定义类型时, 需要在类型名称后面 加上协议名称, 中间已 (:) 分割,遵循多个协议时, 各协议之间以 (,) 分割

// struct SomeStruct: FirstProtocol,AnotherProtocol{

//     // 这里是结构体的定义部分

// }

// 拥有父类的类在组训协议时, 应该将父类的类名放在协议名前面, 以 (,) 分割

// class SomeClass: SomeSuperClass.FirstProtocol,AnotherProtocol{

//     // 这里是类的定义部分

// }

// 属性要求

// 协议 可以要求遵循协议的类型 提供特定名称 和 类型的 实例属性 或类型属性

// 协议 不指定属性是存储型属性 还是 计算型属性, 它只指定属性的名称 和 类型, 此外,协议号指定属性是 可读还是 可读可写的

// 如果协议要求属性是可读可写的, 那么属性不能是常量属性 或只读的计算型属性, 如果协议要求属性是可读的,那么该属性不仅是可读的, 如果代码需要的话. 还可以是可写的

// 协议总是 用 var 关键字来声明变量属性, 在类型名称后面 加上 { set get} 来表示属性是可读可写的, 可读属性则用 {get} 来声明

protocol SomeProtocol{

    var mustBeSettable: Int {get set}

    var doseNotNeedToBeSettable: Int {get}

}

// 在协议中定义类型属性时, 总是使用 static 关键字作为前缀, 当类类型遵循协议时, 除了 static 关键字,还可以使用 class 关键字来声明类型属性:

protocol AnotherProtocol{

    static var someTypeProperty: Int {get set}

}

// 如下所示: 这是一个只含有一个实例属性要求的协议:

protocol FullNamed{

    var fullName: String {get}

}

// FullNamed 协议除了要求遵循协议的类型 提供的 fullName 属性外, 并没有其他要求, 这个协议表示, 任何遵循 FullNamed 的类型, 都必须有一个刻度的 String 类型的实例属性 fullName

// 下面是一个遵循 FullNamed 协议的简单结构体

struct Person: FullNamed{

    var fullName: String

}

let john = Person.init(fullName: "John Appleseed")

// 这个例子定义了一个 Person 的结构体, 用来表示一个具有名字的人, 它遵循了 FullNamed 协议

// Person 结构体的每一个实例都有一个 String 类型的存储型属性, fullName, 这正好满足了 FullNamed 协议的要求, 就以为着 Person 结构体 正确地符合了协议 (如果协议要求未被完全满足, 在编译时会报错)

// 下面是一个更复杂的例子

class Starship: FullNamed{

    var prefix: String?

    var name: String

    init(name: String,prefix: String?) {

        self.name = name

        self.prefix = prefix

    }

    var fullName: String{

        return (prefix != nil ? prefix! + " ":"") + name

    }

}

var ncc1701 = Starship.init(name: "Enterprise", prefix: "USS")

// 方法要求

// 协议可以要求 遵循协议的类型 实现某些指定的实例方法 或类方法, 这些方法作为协议的一部分,像普通方法一样放在协议的定义中, 但是不需要大括号和方法体, 可以在协议中定义具有可变参数的方法, 和普通方法一样, 但是, 不支持为协议中的方法的参数提供默认值

// 正如属性要求中所述, 在协议中定义类方法的时候, 总是使用 static 关键字作为前缀, 当类类型遵循雷伊的时候,除了 static 关键字外, 还可以使用 class 关键字作为前缀.

// 下面的例子定义了一个只含有一个实例方法的协议:

protocol RandomNumberGenerator{

    func random() -> Double

}

// RandomNumberGenerator 协议要求遵循协议的类型必须拥有一个名为 random ,返回值类型为 Double 的实例方法.尽管这里并未指明,但是我们假设返回值在 [0.0,1.0] 区间内

// RandomNumberGenerator 协议并不关心每一个随机数是怎么生成的,它只要求必须提供一个随机数生活器

// 如下所示: 

class LinearCongrentialGenerator: RandomNumberGenerator{

    var lastRandom = 42.0

    let m = 139968.0

    let a = 3877.0

    let c = 29573.0

    func random() -> Double {

        lastRandom = ((lastRandom * a + c).truncatingRemainder(dividingBy: m))

        return lastRandom / m

    }

}

let  generator = LinearCongrentialGenerator.init()

print("Here's a random number : \(generator.random())")

print("And another one: \(generator.random())")

// Mutating 方法要求

// 有时需要在方法中改变方法所属的实例, 例如, 在值类型(即结构体和枚举)的实例方法中, 将 ,mutating 关键字作为方法的前缀, 写在 func 前面, 表示可以在该方法中修改它所属的实例以及实例的任意属性的值,

// 如果你在协议中定义了一个实例方法,该方法会改变遵循该协议的类型的实例, 那么在定义协议是需要在方法前加 ,mutating 关键字, 这使得结构体 和 枚举能够遵循协议并满足此方法要求

// 注意 : 实现协议中的 mutating 方法时, 若是类类型, 则不用写 mutating 关键字, 而对于结构体和枚举, 则必须写 mutataing 关键字

protocol Togglable{

    mutating func toggle()

}

// toggle() 方法在定义的时候,使用 mutating 关键字标记,这表明当它被调用的时候, 该方法将会改变遵循协议的 类型的实例

// 当使用 枚举 或结构体 来实现 Togglable 协议的时候,需要提供一个带有 mutating 前缀的 toggle() 方法

enum OneOffSwitch: Togglable{

    case off, on

    mutating func toggle() {

        switch self {

        case .off:

            self = .on

        case .on:

            self = .off

        }

    }

}

var lightSwitch = OneOffSwitch.off

lightSwitch.toggle()

// 构造器要求

// 协议可以要求遵循协议的类型实现指定的构造器, 你可以想编写普通构造器那样, 在协议的定义里写下构造器的声明, 但不需要写花括号和构造器的实体

protocol SomeProtocol2{

    init(someParameter: Int)

}

// 构造器要求在类中的实现

// 你可以在遵循协议的类中实现构造器, 无论是作为制定构造器 ,还是作为便利构造器, 无论哪种情况,你都必须为构造器实现标上 required 修饰符

class SomeClass: SomeProtocol2{

    required init(someParameter: Int) {

        // 这里是构造器的实现部分

    }

}

// 使用 required 修饰符可以确保所有子类必须 提供此构造器实现, 从而也能复合协议

// 如果类已经被标记为 final ,那么不需要再协议的构造器的实现值使用 required 修饰符,因为 final 类 不能有子类

// 如果一个子类重写了父类的指定构造器, 并且该构造器满足了某个协议的要求, 那么该构造器的实现需要同时标注 required 和 override 修饰符

protocol SomeProtocol3 {

    init()

}

class SomeSuperClass3 {

    init() {

        // 这里是构造器的实现部分

    }

}

class SomeSubClass: SomeSuperClass3, SomeProtocol3 {

    // 因为遵循协议，需要加上 required

    // 因为继承自父类，需要加上 override

    required override init() {

        // 这里是构造器的实现部分

    }

}

// 可失败构造器要求

// 协议还可以为遵循协议的类型定义可失败的构造器要求

// 遵循协议的类型可以通过课时表的构造器 (init?) 或 非可失败的构造器 (init) 来满足协议中定义的可失败的构造器的要求

// 协议中定义的非可失败构造器要求可以通过非可失败构造器 (init) 或隐式解包可失败构造器 (init!)来满足

// 协议作为类型

// 尽管协议本身并未实现任何功能, 但是协议可以被当做一个成熟的类型来使用

// 协议可以像其他类型一样使用, 使用场景如下

// 作为函数, 方法 或结构体中的参数类型 或返回值类型

// 作为常量, 变量 或属性的类型

// 作为数组, 字典 或其他容器中的元素类型

// 注意: 协议是一种类型, 因此协议类型的名称应与其他类型 (Int, Double ,String) 的写法相同, 使用大写字母开头的 驼峰式写法

class Dice {

    let sides: Int

    let generator: RandomNumberGenerator

    init(sides: Int, generator: RandomNumberGenerator) {

        self.sides = sides

        self.generator = generator

    }

    func roll() -> Int {

        return Int(generator.random() * Double(sides)) + 1

    }

}

// 委托 (代理) 模式

// 委托 是一种设计模式, 它允许类 或结构体将一些 需要他们负责的功能 委托给其他类型的实例, 委托模式的实现很简单: 定义协议来封装那些需要被委托的功能, 这样就能确保遵循协议的类型能提供这些功能, 委托模式可以用来响应特定的动作, 或者接受外部数据源的数据, 而无需关心外部数据源的类型

protocol DiceGame{

    var dice: Dice{ get }

    func play()

}

protocol DiceGameDelegate{

    func gameDidStart(_ game: DiceGame)

    func game(_ game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int)

    func gameDidEnd(_ game: DiceGame)

}

// DiceGame 协议可以被任意涉及骰子的游戏遵循, DiceGameDelegate 协议可以被任意类型遵循, 用来追踪 DiceGame 的游戏过程 

// 如下所示. 

class SankesAndLadders: DiceGame{

    let finalSquare = 25

    let dice = Dice.init(sides: 6, generator: LinearCongrentialGenerator())

    var square = 0

    var board: [Int]

    init() {

        board = [Int].init(repeating: 0, count: finalSquare + 1)

        board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02

        board[14] = -10; board[19] = -11; board[22] = -02; board[24] = -08

    }

    var delegate: DiceGameDelegate?

    func play() {

        square = 0

        delegate?.gameDidStart(self)

        gameLoop: while square != finalSquare{

            let diceRoll = dice.roll()

            delegate?.game(self, didStartNewTurnWithDiceRoll: diceRoll)

            switch square + diceRoll {

            case finalSquare:

                break gameLoop

            case let newSquare where newSquare > finalSquare:

                continue gameLoop

            default:

                square += diceRoll

                square += board[square]

            }

        }

        delegate?.gameDidEnd(self)

    }

}

// 如下实例定义了 DiceGameTracker 类, 它遵循 DiceGameDelegate 协议:

class DIcegameTracker: DiceGameDelegate{

    var numberOfTurns = 0

    func gameDidStart(_ game: DiceGame) {

        numberOfTurns = 0

        if game is SankesAndLadders {

            print("Started a new game of Snaks and Ladders")

        }

        print("The game is using a \(game.dice.sides)-sided dice")

    }

    func game(_ game: DiceGame, didStartNewTurnWithDiceRoll diceRoll: Int) {

        numberOfTurns += 1

        print("Rolled a \(diceRoll)")

    }

    func gameDidEnd(_ game: DiceGame) {

        print("The game lasted for \(numberOfTurns) turns")

    }

}