// 2021.6.24
//面向协议编程 协议与扩展的作用


protocol Bird: CustomStringConvertible {
  var name: String { get }
//   var canFly: Bool { get } //扩展实现方法后不需要这个属性 隐式
}

// 使用扩展实现协议的默认方法
extension Bird {
  // 类型继承Flyable 或者 遵循一个叫 Flyable的协议 返回真
  var canFly: Bool { self is Flyable }
}

// 飞行速度
protocol Flyable {
  var airspeedVelocity: Double { get }
}

// Flappy会飞
struct FlappyBird: Bird, Flyable {
  let name: String
  let flappyAmplitude: Double
  let flappyFrequency: Double
  let canFly = true

  var airspeedVelocity: Double {
    3 * flappyFrequency * flappyAmplitude
  }
}

// Penguin是Bird，但它不能飞。好在你没有采用继承的方法来制作所有的鸟Flyable！
struct Penguin: Bird {
  let name: String
//   let canFly = false //扩展实现方法后不需要这个属性 隐式
}

struct SwiftBird: Bird, Flyable {
  var name: String { "Swift \(version)" }
//   let canFly = true
  let version: Double
  private var speedFactor = 1000.0 //外部无法读取
  
  init(version: Double) {
    self.version = version
  }

  // Swift is FASTER with each version!
  var airspeedVelocity: Double {
    version * speedFactor
  }
}

let swiftBird = SwiftBird(version: 2.0)
print(swiftBird.name, swiftBird.version, swiftBird.airspeedVelocity)



// 枚举的 协议编程
// 这个枚举遵守了Bird和Flyable协议 也享有了canFly变量和实现方法
enum UnladenSwallow: Bird, Flyable {
  case african
  case european
  case unknown
  
  var name: String {
    switch self {
    case .african:
      return "African"
    case .european:
      return "European"
    case .unknown:
      return "What do you mean? African or European?"
    }
  }
  
  var airspeedVelocity: Double {
    switch self {
    case .african:
      return 10.0
    case .european:
      return 9.9
    case .unknown:
      fatalError("You are thrown from the bridge of death!")
    }
  }
}

// 覆盖默认行为
// 您的UnladenSwallow类型canFly通过符合Bird协议自动接收实现。
// 但是，你可以使用UnladenSwallow.unknown把canFly修改false了。
extension UnladenSwallow {
  var canFly: Bool {
    self != .unknown
  }
}
// 这个扩展只影响当前类型 对之前遵循Bird协议的Penguin无效
print(UnladenSwallow.unknown.canFly, UnladenSwallow.african.canFly,
      Penguin(name: "King Penguin").canFly)



// 扩展协议
// 您还可以使您自己的协议符合 Swift 标准库中的其他协议并定义默认行为
// 符合 CustomStringConvertible意味着您的类型需要有一个description属性，
// 以便String在需要时自动转换为 a 
// protocol Bird: CustomStringConvertible {
// }

// 用where子名 设置条件 这里是 如果遵循CustomStringConvertible的类型也遵循Bird
// 那么就能获得变量 description
// 继承协议 CustomStringConvertible  即可打印出description的数据内容
extension CustomStringConvertible where Self: Bird {
  var description: String {
    canFly ? "I can fly" : "Guess I'll just sit here :["
  }
}

print(UnladenSwallow .african)


let numbers = [10, 20, 30, 40, 50, 60]
// 获得 数组索引1到3的数据
let slice = numbers[1...3];print(slice[1])//其索引不变
let reversedSlice = slice.reversed() //翻转数组
// map 方法接受一个闭包作为参数
// 然后它会遍历整个 numbers 数组，并对数组中每一个元素执行闭包中定义的操作
let answer = reversedSlice.map { $0 * 10 }
print(answer)


// 对比类和协议 协议只是一个形式 扩展是实际方法 
class Motorcycle {
  var name: String
  var speed: Double

  init(name: String) {
    self.name = name
    speed = 200.0
  }
  
}


// 为了统一这些不同的类型，
// 您需要一个通用的赛车协议。借助称为追溯建模的奇思妙想
// 1
protocol Racer {
  var speed: Double { get }  // 速度是赛车手唯一关心的
}

// 通过扩展协议给 结构体 提供默认实现方法 
extension FlappyBird: Racer {
  var speed: Double {
    airspeedVelocity  //把飞行速度 转给协议中的车速度
  }
}

extension SwiftBird: Racer {
  var speed: Double {
    airspeedVelocity
  }
}

extension Penguin: Racer {
  var speed: Double {
    42  // full waddle speed
  }
}

extension UnladenSwallow: Racer {
  var speed: Double {
    canFly ? airspeedVelocity : 0.0
  }
}

extension Motorcycle: Racer {}

// 符合Racer协议 的一个数组 空格处可以换行
// 所以声明Racer协议的class 类Motorcycle 也能进入数组中
let racers: [Racer] =
  [UnladenSwallow.african,
   UnladenSwallow.european,
   UnladenSwallow.unknown,
   Penguin(name: "King Penguin"),
   SwiftBird(version: 5.1),
   FlappyBird(name: "Felipe", flappyAmplitude: 3.0, flappyFrequency: 20.0),
   Motorcycle(name: "Giacomo")]//里面有一个类


func topSpeed(of racers: [Racer]) -> Double {
  racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}

print(topSpeed(of: racers))// 5100
 


// 泛型方法 + 协议的实现
func topSpeed<RacersType: Sequence>(of racers: RacersType) -> Double
    /*2*/ where RacersType.Iterator.Element == Racer {
  // 3
  racers.max(by: { $0.speed < $1.speed })?.speed ?? 0.0
}

// Sequence协议的定义
/*
protocol Sequence{

associatedtype Iterator:IteratorProtocol

func makeIterator()->Iterator

}
*/

// IteratorProtocol 的定义
/*
public protocol IteratorProtocol{

associatedtype Element

public mutating func next()->Self.Element?

}
*/
print(topSpeed(of: racers[1...3])) // 42