classes.swift

import Foundation

class Example {
    var a = 0
    var b: String

    init(a: Int) { // Constructor
        self.a = a
        b = "name"                  // An error if a declared property isn't initialized
    }
}

// External param names are required...
let eg = Example(a: 1)
print(eg.a)              // 1


// ...Unless the params are declared with leading underscores.

class Example2 {
    var a = 0
    var b = 0

    init(_ a: Int, _ b: Int) {
        self.a = a
        self.b = b
    }
}

let eg2 = Example2(1, 2)
print(eg2.a)            // 1
print(eg2.b)            // 2


// # Lazy properties

// Lazy properties' initial value aren't
// initialized until the first time the
// property is accessed.

class Podcast {
    lazy var episode = Episode() // `var` declaration is required.
}

class Episode {
    var audio = "somefile.mp3"
}

var podcast = Podcast()          // episode has not been initialized yet.
print(podcast.episode.audio)   // somefile.mp3

// # Computed properties

// Computed properties don't store a value. Instead, getters / setters
// are provided to retrieve and set _other_ properties.

class Window {
    var x = 0.0, y = 0.0
    var width = 100.0, height = 100.0

    var center: (Double, Double) {
        get {
            return (width / 2, height / 2)
        }

        set(newVal) {
            x = newVal.0 - (width / 2)
            y = newVal.1 - (height / 2)
        }
    }
}

var win = Window()
print(win.center)               // (50.0, 50.0)
win.center = (0.0, 10.0)
print(win.x)                    // -50.0
print(win.y)                    // -40.0

// The param to `set` can be omitted and a magic "newValue"
// can be used to referenced the new value.
/*
set {
x = newValue.0 - (width / 2)
}
*/

// # Read-only computed properties

class Song {
    var title = ""
    var duration = 0.0
    var metaInfo: [String:String] {
        return [
            "title": self.title,
            "duration": NSString(format: "%.2f", self.duration) as String,
        ]
    }
}

var song = Song()
song.title = "Rootshine Revival"
song.duration = 2.01
print(song.metaInfo["title"]!)    // Rootshine Revival
print(song.metaInfo["duration"]!) // 2.01

// # Property Observers

// Property observers can be added onto any properties
// (including inherited) except for lazy computed props.

class Website {
    var visitors: Int = 0 {             // An explicit type is required
        willSet(newVisitorCount) {          // Called before the prop is set
            visitors = newVisitorCount + 1  // Warning. Can't set within its own willSet
        }
        didSet {                            // Called after a new val is set
            print(visitors - oldValue)    // oldValue is magically defined
        }
    }
}

var site = Website()
site.visitors = 1
print(site.visitors)                 // 1

// # Type Properties
// AKA class variables
class Body {
    /*    class var age = 0                 // error: class variables not yet supported */
    // Computed type property
    class var size: Int {
        return 10
    }
}
print(Body.size)                     // 10

// # Type Methods
// AKA class methods
class Banana {
    var color = "green"
    class func genus() -> String {
        return "Musa"
    }
}
print(Banana.genus())                // Musa

// # Instance methods

class Month {
    var name: String

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

    func shortened() -> String {
        return name[name.startIndex..<advance(name.startIndex, 3)]
    }
}
print(Month(name: "January").shortened())    // Jan

// # Inheritance

// Swift classes do not inherit from a universal base class.

class Bicycle {
    var tireWidth: Double
    var topSpeed: Double
    var name: String
    var gears: Int
    // Marking a method/property with `@final` prevents it from being overridden
    final var color = "green"

    init() {
        tireWidth = 30.5
        topSpeed = 10.0
        name = "regular ol' bike"
        gears = 3
    }

    func go(distance: Double) {
        print("Went \(distance) at a top speed of \(topSpeed) in my \(name)")
    }
}

class MountainBike : Bicycle {
    /* var tireWidth = 64.0 // Cannot override property in the declaration */
    override init() {
        super.init()

        tireWidth = 64.0
        name = "mountain bike"
        gears = 12
    }
    // Override parent's methods via `override` keyword
    override func go(distance: Double) {
        super.go(distance)
        print("Did \(distance) on a mountain bike")
    }

    // A getter/setter override can _any_ inherited property.
    override var topSpeed: Double {
        get {
            return super.topSpeed - 4.0
        }
        set {
            super.topSpeed = newValue
        }
    }

    // Property observer
    override var gears: Int {
        didSet {
            print("Gears was changed to \(gears)")
        }
    }
}

var mountainBike = MountainBike()              // Gears was changed to 12
mountainBike.topSpeed = 6.0
print(mountainBike.topSpeed)                 // 2.0
mountainBike.go(12.0)                          // Went 12.0 at a top speed of 10.0 in my mountain bike
// Did 12.0 on a mountain bike

// # Initializers

// 'Convenience' initializers overload empty
// initializers that populate the params
// in 'designated' initializers.

class iOS {
    var version: String

    init(version: String) {
        self.version = version
    }

    convenience init() {
        self.init(version: "8.0.0")
    }
}

var os = iOS()
print(os.version)                          // 8.0.0

// # ARC and reference cycles

// Strong reference cycles happen when two objects
// hold strong references to each other so that neither
// can be deallocated (à la memory leaks in garbage collected langs)

// Strong references can be resolved by declaring
// references as `weak` or `unowned`

// Use a weak reference whenever it's valid for the reference
// to be nil at any point. These are optional types.

class Driver {
    weak var car: Car? // Strong reference to car.

    deinit {
        print("Driver deinitialized")
    }
}

class Car {
    weak var driver: Driver? // Weak reference to driver.

    deinit {
        print("Car deinitialized")
    }
}

var driver: Driver?
var car: Car?

driver = Driver()
car = Car()
driver!.car = car
car!.driver = driver

driver = nil               // No more strong references to driver.
car = nil                  // No more strong references to car.

// Unowned references are like weak references except they always
// refer to a value, so they're non-nil.

class Artist {
    var instrument: Instrument?  // Strong reference to instrument.
}

class Instrument {
    unowned let artist: Artist   // Unowned reference to artist.
    init (artist: Artist) {
        self.artist = artist
    }
}

var artist: Artist?
artist = Artist()
artist!.instrument = Instrument(artist: artist!)

artist = nil        // Both objects are deallocated since there are no more strong references.

// # Access control

// Access control in Swift is very much package-based.
// `private`: Can only be accessed from the same source file that it's defined
// `internal`: Can be accessed anywhere in the target it's defined
// `public`: Accessible anywhere in the target and anywhere its module is imported

// Defaults to `internal` if not explicitly declared.

internal class Image { // Accessible in the same target
    internal var name : String

    private var mime : String {     // Accessible only in this file. Never settable.
        get {
            return "image/\(name.pathExtension)"
        }
    }

    init(name: String) {
        self.name = name
    }
}
var img = Image(name: "foo.png")

public class Webpage {
    public var title : String
    public var created : NSDate
    private(set) var images : [Image] // Readable within the same target but only writable in this file
    var slug : String {
        return created.description + title
    }

    init(title: String) {
        self.title = title
        self.created = NSDate()
        self.images = []
    }
}

var webPage = Webpage(title: "blog post")
webPage.images.append(Image(name:"panda.gif"))