/*
     • 使用可选链式调用代替强制展开
     • 为可选链式调用定义模型类
     • 通过可选链式调用访问属性
     • 通过可选链式调用调用方法
     • 通过可选链式调用访问下标
     • 连接多层可选链式调用
     • 在方法的可选返回值上进行可选链式调用
     */
    
    //可选链式调用是一种可以在当前值可能为 nil 的可选值上请求和调用属性、方法及下标的方法。如果可选值有 值,那么调用就会成功;如果可选值是 nil ,那么调用将返回 nil 。多个调用可以连接在一起形成一个调用 链,如果其中任何一个节点为 nil ,整个调用链都会失败,即返回 nil 。
    
    //使用可选链式调用代替强制展开
    //通过在想调用的属性、方法、或下标的可选值后面放一个问号( ? ),可以定义一个可选链。这一点很像在可选 值后面放一个叹号( ! )来强制展开它的值。它们的主要区别在于当可选值为空时可选链式调用只会调用失 败,然而强制展开将会触发运行时错误。
    
    //下面几段代码将解释可选链式调用和强制展开的不同
    class Person {
    
        var residence:Residence?
    
        
    }
    
    class Residence {
    
        var numberOfRooms = 1
        
    }
    //Residence 有一个 Int 类型的属性 numberOfRooms ,其默认值为 1 。 Person 具有一个可选的 residence 属 性,其类型为 Residence? 。
    //假如你创建了一个新的 Person 实例,它的 residence 属性由于是是可选型而将初始化为 nil ,在下面的代码中, jo hn 有一个值为 nil 的 residence 属性:
    let john = Person()
    
    //如果使用叹号( ! )强制展开获得这个 john 的 residence 属性中的 numberOfRooms 值,会触发运行时错误,因为 这时 residence 没有可以展开的值:
//        let roomCount = john.residence!.numberOfRooms // 这会引发运行时错误
    
    //可选链式调用提供了另一种访问 numberOfRooms 的方式,使用问号( ? )来替代原来的叹号( ! ):
    if let roomCount = john.residence?.numberOfRooms {
         print("John's residence has \(roomCount) room(s).")
    }else{
         print("Unable to retrieve the number of rooms.")
    }
    // 打印 “Unable to retrieve the number of rooms.”
    
    //在 residence 后面添加问号之后,Swift 就会在 residence 不为 nil 的情况下访问 numberOfRooms 。
    
    //因为访问 numberOfRooms 有可能失败,可选链式调用会返回 Int? 类型,或称为“可选的 Int ”。如上例所 示,当 residence 为 nil 的时候,可选的 Int 将会为 nil ,表明无法访问 numberOfRooms 。访问成功时,可选的Int 值会通过可选绑定展开,并赋值给非可选类型的 roomCount 常量。
   // 要注意的是,即使 numberOfRooms 是非可选的 Int 时,这一点也成立。只要使用可选链式调用就意味着numberOfRooms 会返回一个 Int? 而不是 Int 。
    //可以将一个 Residence 的实例赋给 john.residence ,这样它就不再是 nil 了:
    john.residence = Residence()
    
    //john.residence 现在包含一个实际的 Residence 实例,而不再是 nil 。如果你试图使用先前的可选链式调用访问 numberOfRooms ,它现在将返回值为 1 的 Int? 类型的值:
    
    if let roomCount = john.residence?.numberOfRooms {
        print("John's residence has \(roomCount) room(s).")
    }else {
        print("Unable to retrieve the number of rooms.")
    }
    // 打印 “John's residence has 1 room(s).”
    
    
    //为可选链式调用定义模型类
    
    //通过使用可选链式调用可以调用多层属性、方法和下标。这样可以在复杂的模型中向下访问各种子属性,并且判断能否访问子属性的属性、方法或下标。
    //下面这段代码定义了四个模型类,这些例子包括多层可选链式调用。为了方便说明,在 Person 和 Residence 的基 础上增加了 Room 类和 Address 类,以及相关的属性、方法以及下标。
    
    //Person1 类的定义基本保持不变:
    //  Residence 类比之前复杂些,增加了一个名为 rooms 的变量属性,该属性被初始化为 [Room] 类型的空数组:
    
    class Person1 {
        
        var residence:Residence1?
        
    }

    
    class Residence1 {
    
        var rooms:Array<Room>
        
        var numberOfRooms: NSInteger {
        
            return rooms.count
        }
      
        subscript(i:NSInteger) -> Room {
        
            get {
            return rooms[i]
            }
            set {
            
                rooms[i] = newValue
            }
        }
        func prinfNumberOfRooms() {
            print("The number of rooms is \(numberOfRooms)")
        }
        var address:Address?
        
        init(rooms:Array<Room> , address: Address?) {
            self.rooms = rooms
            self.address = address
        }
        
    }
    
    class Room {
    
        let name: String
        init(name: String) {
            self.name = name
        }
        
    }
    
    class Address {
    
        var buildingName:String?
        var buildingNumber:String?
        var street:String?
        func buildingIdentifier() -> String? {
            if buildingName != nil {
                return buildingName
            }else if buildingNumber != nil && street != nil {
            
                return "\(buildingNumber) \(street)"
            }else {
            
                return nil
            }
        }
    }
    
    
    //下面的代码创建了一个 Person 实例,然后像之前一样,尝试访问 numberOfRooms 属性:
    //因为 john.residence 为 nil ,所以这个可选链式调用依旧会像先前一样失败。
    let john1 = Person1()
    if let roomCount = john1.residence?.numberOfRooms {
        print("John's residence has \(roomCount) room(s).")
    } else {
        print("Unable to retrieve the number of rooms.")
    }
    // 打印 “Unable to retrieve the number of rooms.”
    
   // 还可以通过可选链式调用来设置属性值:
    
    let someAddress = Address()
    someAddress.buildingNumber = "29"
    someAddress.street = "Acacia Road"
    john1.residence?.address = someAddress
    
   // 在这个例子中,通过 john.residence 来设定 address 属性也会失败,因为 john.residence 当前为 nil 。
    
    
    func createAddress() -> Address {
        print("Function was called.")
        let someAddress = Address()
        someAddress.buildingNumber = "29"
        someAddress.street = "Acacia Road"
        return someAddress
    }
    john1.residence?.address = createAddress()
    
    //没有任何打印消息,可以看出 createAddress() 函数并未被执行。
    
    //通过可选链式子调用调用方法
    //func prinfNumberOfRooms() {
     //   print("The number of rooms is \(numberOfRooms)")
    //}
    
    //最后通过判断调用
    if john1.residence?.prinfNumberOfRooms() != nil {
        print("It was possible to print the number of rooms.")
    } else {
        print("It was not possible to print the number of rooms.")
    }
    // 打印 “It was not possible to print the number of rooms.”
    //同样的,可以据此判断通过可选链式调用为属性赋值是否成功
    
    if (john1.residence?.address = someAddress) != nil {
        print("It was possible to set the address.")
    } else {
        print("It was not possible to set the address.")
    }
    // 打印 “It was not possible to set the address.”
    
    
    //同样的,可以据此判断通过可选链式调用为属性赋值是否成功。在上面的通过可选链式调用访问属性.我们尝试给 john1.residence 中的 address 属性赋值,即使 residence 为 nil 。通过可选链式调用给属性赋 值会返回 Void? ,通过判断返回值是否为 nil 就可以知道赋值是否成功:
    if let firstRoomName = john1.residence?[0].name {
        print("The first room name is \(firstRoomName).")
    } else {
        print("Unable to retrieve the first room name.")
    }
    // 打印 “Unable to retrieve the first room name.”
    
    //通过可选链式调用访问下标
    if let firstRoomName = john1.residence?[0].name {
        print("The first room name is \(firstRoomName).")
    } else {
        print("Unable to retrieve the first room name.")
    }
    // 打印 “Unable to retrieve the first room name.”
    
    //如果创建一个Residence1实例，并为其rooms数组添加一些Room实例，然后将residence实例赋值给john.residence,那就可以通过可选链和下标来访问数组
   // let johnsHouse = Residence1()
   // johnsHouse.rooms.append(Room(name: "Living Room"))
    //johnsHouse.rooms.append(Room(name: "Kitchen"))
    //john1.residence = johnsHouse
    //if let firstRoomName = john1.residence?[0].name {
     //   print("The first room name is \(firstRoomName).")
    //} else {
      //  print("Unable to retrieve the first room name.")
    //}
    // 打印 “The first room name is Living Room.”