Protection de l’état

Fait partie de la section Programmation orientée objet du Journey Swift de Coddy. Leçon 19 sur 57.

Un invariant est une règle qui doit toujours être respectée pour une valeur, comme « un solde n'est jamais négatif ». Un type protège ses invariants en vérifiant chaque modification avant de l'appliquer :

struct BankAccount {
    private(set) var balance = 0

    mutating func withdraw(_ amount: Int) -> Bool {
        guard amount > 0, amount <= balance else { return false }
        balance -= amount
        return true
    }

    mutating func deposit(_ amount: Int) {
        guard amount > 0 else { return }
        balance += amount
    }
}

var acc = BankAccount()
acc.deposit(100)
print(acc.withdraw(150))
print(acc.withdraw(40))
print(acc.balance)

Sortie :

false
true
60

Lorsqu’un appelant doit savoir pourquoi une modification a été refusée, la méthode peut lever une erreur au lieu de retourner false. Le type d’erreur est une énumération qui est conforme à Error :

enum TransferError: Error {
    case invalidAmount
    case insufficientFunds(missing: Int)
}

struct Account {
    private(set) var balance: Int

    mutating func withdraw(_ amount: Int) throws {
        guard amount > 0 else { throw TransferError.invalidAmount }
        guard amount <= balance else { throw TransferError.insufficientFunds(missing: amount - balance) }
        balance -= amount
    }
}

var acc = Account(balance: 30)
do {
    try acc.withdraw(50)
} catch TransferError.insufficientFunds(let missing) {
    print("missing \(missing)")
} catch {
    print("other error")
}

Sortie :

missing 20

Gardez chaque modification des données protégées à l’intérieur de méthodes qui les vérifient. Si la propriété pouvait être définie depuis l’extérieur, n’importe quelle ligne de code pourrait enfreindre la règle sans que le type ne s’en aperçoive :

struct Temperature {
    private(set) var kelvin: Double   // doit rester >= 0
    mutating func cool(by amount: Double) {
        kelvin = max(0, kelvin - amount)   // le seul moyen de le baisser
    }
}

Une opération qui modifie plusieurs propriétés doit les laisser cohérentes même si elle échoue à mi-chemin. Vérifie d’abord tout, puis modifie l’état :

struct Inventory {
    private(set) var stock: [String: Int] = ["tea": 2, "jam": 1]

    mutating func sell(_ items: [String]) -> Bool {
        var needed: [String: Int] = [:]
        for i in items { needed[i, default: 0] += 1 }
        for (item, n) in needed where (stock[item] ?? 0) < n { return false }
        for (item, n) in needed { stock[item]! -= n }
        return true
    }
}

var inv = Inventory()
print(inv.sell(["tea", "jam", "jam"]))
print(inv.stock["tea"]!)
print(inv.sell(["tea", "jam"]))
print(inv.stock["tea"]!)

Sortie :

false
2
true
1

Défi

Facile

Complétez la structure Seats, qui vend des billets pour un spectacle disposant de capacity places. sold est private(set). buy(_:) lève TicketError.invalidCount pour un nombre inférieur à 1, TicketError.soldOut lorsqu’il ne reste aucune place, et TicketError.notEnough(left:) lorsqu’il reste moins de places que demandé ; sinon, elle ajoute les billets à sold.

Le code fourni lit la capacité et un nombre demandé par ligne. Pour chacune, il affiche sold 3, left 7, invalid count, sold out ou only 2 left.

Votre code doit être placé dans TicketError.swift et Seats.swift. main.swift contient le code fourni d’entrée/sortie et ne peut pas être modifié.

Essayez vous-même

// Code d'entrée/sortie fourni : le garder tel quel
var input: [String] = []
while let line = readLine() { input.append(line) }
var seats = Seats(capacity: Int(input[0])!)
for line in input.dropFirst() {
    let n = Int(line)!
    do {
        try seats.buy(n)
        print("sold \(n), left \(seats.capacity - seats.sold)")
    } catch TicketError.invalidCount {
        print("invalid count")
    } catch TicketError.soldOut {
        print("sold out")
    } catch TicketError.notEnough(let left) {
        print("only \(left) left")
    } catch {
        print("unexpected")
    }
}