Transaction Wrapper

transaction.swift

public enum Condition {
    case new
    case safe
}
public enum Transacting<T> {
    case known(T)
    case changing(known: T, tentative: T)

    public mutating func stage(_ value: T) {
        switch self {
        case .known(let t):
            self = .changing(known: t, tentative: value)
        case .changing(let known, _):
            self = .changing(known: known, tentative: value)
        }
    }

    public mutating func fallback() {
        switch self {
        case .changing(known: let known, _):
            self = .known(known)
        case .known:
            break
        }
    }

    public mutating func accept() {
        switch self {
        case .known:
            break
        case .changing(_, let tentative):
            self = .known(tentative)
        }
    }

    public mutating func set(_ value: T) {
        self = .known(value)
    }


    public func get(_ condition: Condition) -> T {
        switch (condition, self) {
        case (.new, .known(let value)):
            return value
        case (.new, .changing(_, let tentative)):
            return tentative
        case (.safe, .known(let value)):
            return value
        case (.safe, .changing(let known, _)):
            return known
        }
    }
}

extension Transacting: Codable where T: Codable {}
extension Transacting: Equatable where T: Equatable {
    mutating func stage(_ value: T) {
        switch self {
        case .known(let t):
            if t != value {
                self = .changing(known: t, tentative: value)
            }
        case .changing(let known, _):
            self = .changing(known: known, tentative: value)
        }
    }
}
extension Transacting: Hashable where T: Hashable {}