swift Property

import Foundation

// property: 

//      1. Stored property : Class Struct

//      2. Calculated property : Class Struct Enum

//      3. Type property AKA static property

//      4. Property observer  : Stored property

struct Range {

    var start: Int

    let length: Int

}

class Zone {

    var start : Int = 0

    let length : Int = 3

}

var rangeA = Range(start : 1, length : 3)

rangeA.start = 3

//rangeA.length = 4

let rangeB = Range(start: 2,length:2)

let rangeBClass = Zone()

rangeBClass.start = 4

//  if you declare let instance, you can't modify var property for value type

//  But you can modify it for reference type

//  rangeB.start = 3

// lazy stored property : 

//      1. can only be var (constant must have value when initialization)

//      2. calculated until been used not when initialized

class FileLoader {

    //  imagine the initialization took a long time to load

    //  imagination code here

    var fileName = "filename" //not important, just make it more real

}

class DataLoader {

    var SourceData = [String]()

    lazy var SourceFile = FileLoader()

}

var someLoader = DataLoader()

print(someLoader.SourceData)

someLoader.SourceData.append("aaa")

someLoader.SourceFile.fileName// SourceFile been initialized fist time

// computed property

struct Point{

    var x : Int

    var y : Int

}

struct Size{

    var width: Int

    var height: Int

}

struct Rect{

    var origin : Point

    var size : Size

    var center : Point{

        get{

            let center_x = origin.x + size.width/2

            let center_y = origin.y + size.height/2

            return Point(x:center_x,y:center_y)

        }

        set{ // remove set then the property is readonly

            origin.x = newValue.x - size.width/2

            origin.y = newValue.y - size.height/2

        }

    }

}

var alpha = Rect(origin: Point(x:0,y:0), size: Size(width: 10, height: 10))

print(alpha.center.x)

alpha.center = Point(x: 20,y:20)

print(alpha.origin.x)

// *******

// Property Observer:

//      1. willSet called before value stored

//      2. didSet called after value stored

struct PropertyObserve {

    var someInt : Int = 1

    var someOtherInt : Int {

        // get & set can't coexist with property observer

        //get {

        //    return someInt + 1

        //}

        //set {

        //    someInt = newValue - 1

        //}

        willSet{

            print("we are setting new value now: it is \((newValue))")

        }

        didSet{

            if someOtherInt > oldValue{

                print("getting bigger")

            }else{

                print("getting smaller")

            }

        }

    }

}

// the first time value been initialized it will not call willSet

// because property observer only respond to value changes, not value init

var testObject = PropertyObserve(someInt: 1, someOtherInt: 2)

testObject.someOtherInt = 3

// *********************

// Type property also known as static property

// for static property you mut give it a default value

enum Woman {

    static var isaWoman : Bool = true

    static var braSize : Character {

        switch self.braSize {

        case "A":

            return "A"

        default:

            return "B"

        }

    }

}

struct Egg {

    static var isRound : Bool = true

}

class Car {

    static var wheel = 4

    var brand:String {

        set{

            //self.brand = "whatthefaak" // this will failjh

        }

        get{

           return "hooray"

        }

    }

    // put class instead of static make child class able to override

    class var canbeInHerit:Int{

        return 3

    }

}

var carA = Car()

var carB = Car()

//Car.brand = "I just change it"

print(carA.brand)

carA.brand = "asa"

print("what")

print(carA.brand)

class Car {

    var brand:String {

        set{

            //self.brand = "whatthefaak"

            //set was used to set other property

        }

        get{

           return "hooray"

        }

    }

}

var carA = Car()

var carB = Car()

print(carA.brand)

carA.brand = "asa"

print("what")

print(carA.brand)

// example from the guide

struct SoundChannel{

    static let maxVoice = 10

    static var maxMark : Int = 0

    var currentMark : Int {

        didSet{

            if currentMark > SoundChannel.maxVoice {

                currentMark = SoundChannel.maxMark

            }

            if currentMark > SoundChannel.maxMark {

                SoundChannel.maxMark = currentMark

            }

        }

    }

    

}

var leftChannel = SoundChannel(currentMark: -4)

print(leftChannel.currentMark)