failable initializers, failable initializers for enumerations, override failable initializers

// failable initializers
// failable initializers are implemented for numeric type conversions. To ensure conversion between numeric types maintains the value exactly, use the init(exactly:) initializer. If the type conversion can’t maintain the value, the initializer fails.

var wholeNumber = 1234.0
var pi = 3.14159

if let numberConversion = Int(exactly: wholeNumber){
    print("\(numberConversion) is maintain the value for \(wholeNumber)")
}

let newValue = Int(exactly: pi)
// the newValue is of type Int?, not Int

if newValue == nil{
    print("\(newValue ?? 0) is not maintain the value for \(pi) conversion")
}

struct Animal{
    var species: String
    init?(species: String){
        if species.isEmpty {return nil}
        self.species = species
    }
}

var someHorse = Animal(species: "Horse")
if let horse = someHorse{
    print("an animal initialized with name of \(horse.species)")
}




// failable initializers for enumerations
enum Temprature{
    case celsius, kelvin, fahrenheit
    init?(symbol: Character){
        switch symbol {
            case "c":
            self = .celsius
            case "k":
            self = .kelvin
            case "f":
            self = .fahrenheit
            default:
            return nil
        }
    }
}

var celsiusInit = Temprature(symbol: "c")
if celsiusInit != nil{
    print("initialization of temprature unit in celsius is succeed")
}

var unknownUnit = Temprature(symbol: "x")
if unknownUnit == nil{
    print("this is not a defined unit, so initialization is failed")
}



// failable initializers for enumerations with raw values
enum tempratureUnit: Character{
    case celsius = "c", kelvin = "k", fahrenheit = "f"
}
var fahrenheitUnit = tempratureUnit(rawValue: "f")
if fahrenheitUnit != nil{
    print("defined unit f for fahrenheit is initialized")
}

var Undefined = tempratureUnit(rawValue: "x")
if Undefined == nil{
    print("undefined unit x is not initialized")
}


//example:
class Resolute{
    var navigationSystem: Bool
    init(status: Bool){
        if status != true {print("navigation system not responding")}
        self.navigationSystem = status
    }
}
func lifeSupportSystem(){
        print("Alert! life support system execution started.")
    }
class PilotModule: Resolute{
    var engine: Bool
    
    init(engineStatus: Bool, navigationStatus: Bool){
        if engineStatus == false {lifeSupportSystem()
        }
        self.engine = engineStatus
        super.init(status: navigationStatus)
    }
}
var moduleOne = PilotModule(engineStatus: false,navigationStatus: true)




// propagation of initialization failure
class vehicle{
    var currentSpeed: Int
    init?(speed: Int){
        if speed == 0 {return nil}
        self.currentSpeed = speed
    }
}
class Tesla: vehicle{
    var batteryStatus: Int
    init?(battery: Int, speed: Int){
        if battery < 1 {return nil}
        self.batteryStatus = battery
        super.init(speed: speed)
    }
}
if let teslaOne = Tesla(battery: 67, speed: 60){
    print("the current battery status of tesla one is: \(teslaOne.batteryStatus) percent, and speed is: \(teslaOne.currentSpeed) KMPH")
}

if let teslaTwo = Tesla(battery: 0, speed: 60){
    print("the current battery status of tesla two is: \(teslaTwo.batteryStatus) percent, and speed is: \(teslaTwo.currentSpeed) KMPH")
}
else{print("tesla is not runnning, battery is empty")}




//override failable initializers
// the only to overirde a failable initializer is force unwrapping
class Document{
    var name: String?
    init() {}
    init?(name: String){
        if name.isEmpty { return nil }
        self.name = name
    }
}
class RenameDocument: Document{
    override init(){
        super.init()
        self.name = "Untitled"
        
    }
    override init(name: String){
        super.init()
        if name.isEmpty {
            self.name = "Untitled"
        } 
        else{
            self.name = name
        }
        
    }
}
// let's resolve runtime error
class resolve: Document{
    override init(){
        super.init(name: "document")!
    }
    
}