import Foundation

//
struct STR {
    //
    var a: Int = 2
}

//
class TRIDA {
    //
    var a: Int = 3
}

//
var t : TRIDA? = TRIDA()
var s : STR? = STR()

// CFGetRetainCount(o) - vypise refCount (v Objective-C/Swift se rika "retain count")
// napise 2: jednou za "t" + jednou za argument volani CFGetRetainCount
print(CFGetRetainCount(t))

// podminenene se vytvori novy "let _t : TRIDA = t", tj.
// 1) _t je konstanta,
// 2) _t dostane obsah prirazenim z "t", tj. navysuje refCount
if let _t = t {
    // napise "3": 1x "t", 1x "_t", 1x funkce CFGetRetainCount
    print(CFGetRetainCount(_t))
    
    // zapisuju do objektu
    _t.a = 1
    
    // _t zanika
}

// podminenene se vytvori novy "var _t : TRIDA = t", tj.
// 1) _t je promenna,
// 2) _t dostane obsah prirazenim z "t", tj. navysuje refCount
if var _t = t {
    // napise "3"
    print(CFGetRetainCount(_t))
    
    // zapisuju do objektu
    _t.a = 1
    
    // muzu modifikovat _t, ale nedava to zadny smysl
    _t = TRIDA()
    
    // _t zanika, "t" snizuje refCount
}

// vznika novy let _s: STR, podminene
// !!! dochazi ke kopii hodnoty
if let _s = s {
    // nelze priradit, nebot _s je konstanta
    //
    // _s.a = 1
}


// vznika novy var _s: STR, podminene
// !!! dochazi ke kopii hodnoty
if var _s = s {
    // lze zapsat, ale zapisuju do struktury,
    // ktera za chvili zanikne
    _s.a = 1
}

// co tedy chceme provest?
// pokud chceme podminene zapsat do atributu, pak nejspis
t?.a = 10
s?.a = 20

// nebo muzeme provadet zmeny na kopii dat, a pak atomicky kopirovat
func nastavS(s: STR?) -> STR? {
    //
    guard var _s = s else { return nil }
    
    //
    _s.a = 1
    // ... dalsi zmeny
    
    //
    return _s
}

// provedu na cele strukture
s = nastavS(s: s)

//
class TRIDA_B {
    // ukaze se, ze Int! je ekvivalent Int?, kde se zanedbava testovani
    var nei: Int!
}

//
let p = TRIDA_B()

// slitne
// print(p.nei!)

// lze !!! testovat na nil
if p.nei == nil {
    //
    p.nei = 1
}

// dokonce tohle...
// tj. "nei" je typu Int?, akorat se nevyzaduje explicitni unwrap a dela se implicitne
p.nei = nil

// optional binding, kopiruju hodnotu
if let _nei = p.nei {
    //
    print("Neco tam je \(_nei) ")
} else {
    //
    print("Nei prazdno")
}