//: Playground - noun: a place where people can play

import UIKit

var str = "Hello, playground"

enum Movement {
    case Left
    case Right
    case Top
    case Bottom
}

let aMovement = Movement.Left

switch aMovement {
case .Left:
    print("left")
default:
    print("Unknow")
}

if case .Left = aMovement {
    print("Left")
}

if .Left == aMovement {
    print("Left")
}

enum Season: Int {
    case Spring = 0
    case Summer = 1
    case Autumn = 2
    case Winter = 3
}

enum House: String {
    case ZhangSan = "I am zhangsan"
    case LiSi = "I am lisi"
}

let zs = House.ZhangSan
print(zs.rawValue)

enum Constants: Double {
    case π = 3.14159
    case e = 2.71828
    case φ = 1.61803398874
    case λ = 1.30357
}

let pai = Constants.π
print(pai.rawValue)


enum CompassPoint: String {
    case North, South, East, West
}

let n = CompassPoint.North
print(n.rawValue)

let s = CompassPoint(rawValue: "South");


enum VNodeFlags : UInt32 {
    case Delete = 0x00000001
    case Write = 0x00000002
    case Extended = 0x00000004
    case Attrib = 0x00000008
    case Link = 0x00000010
    case Rename = 0x00000020
    case Revoke = 0x00000040
    case None = 0x00000080
}

enum Character {
    
    enum Weapon {
        case Bow
        case Sword
        case Lance
        case Dagger
    }
    
    enum Helmet {
        case Wooden
        case Iron
        case Diamond
    }
    
    case Thief
    case Warrior
    case Knight
}

let character = Character.Thief
let weapon = Character.Weapon.Bow
let helmet = Character.Helmet.Iron


struct Scharacter {
    enum CharacterType {
        case Thief
        case Warrior
        case Knight
    }
    
    enum Weapon {
        case Bow
        case Sword
        case Lance
        case Dagger
    }
    
    let type: CharacterType
    let weapon: Weapon
}

let sc = Scharacter(type: .Thief, weapon: .Bow)
print(sc.type)


enum Trade {
    case Buy(stock: String, amount: Int)
    case Sell(stock: String, amount: Int)
}

let trade = Trade.Buy(stock: "Car", amount: 100)
if case let Trade.Buy(stock, amount) = trade {
    print("buy \(amount) of \(stock)")
}

enum Trade0 {
    case Buy(String, Int)
    case Sell(String, Int)
}

let trade0 = Trade0.Buy("Car0", 100)
if case let Trade0.Buy(stock, amount) = trade0 {
    print("buy \(amount) of \(stock)")
}


enum Wearable {
    enum Weight: Int {
        case Light = 2
    }
    
    enum Armor: Int {
        case Light = 2
    }
    
    case Helmet(weight: Weight, armor: Armor)
    
    
    func attributes() -> (weight: Int, armor: Int) {
        switch self {
        case .Helmet(let w, let a):
            return (weight: w.rawValue * 2, armor: a.rawValue * 4)
  
        }
    }
}

let test = Wearable.Helmet(weight: .Light, armor: .Light).attributes()
print(test)

enum Device {
    case iPad, iPhone, AppleTV, AppleWatch
    func introduced() -> String {
        switch self {
        case .AppleTV: return "\(self) was introduced 2006"
        case .iPhone: return "\(self) was introduced 2007"
        case .iPad: return "\(self) was introduced 2010"
        case .AppleWatch: return "\(self) was introduced 2014"
        }
    }
}
print (Device.iPhone.introduced())



enum Device1 {
    case iPad, iPhone
    var year: Int {
        switch self {
        case .iPad:
            return 2010
        case .iPhone:
            return 2007
    }
    }
}

let iPhone = Device1.iPhone
print(iPhone.year)



enum Device2 {
    case AppleWatch
    
    static func fromSlang(term: String) -> Device2? {
        if term == "iWatch" {
            return .AppleWatch
        }
        return nil
    }
}

print(Device2.fromSlang(term: "iWatch") ?? "nil")


enum TriStateSwitch {
    case Off, Low, High
    
    mutating func next() {
        switch self {
        case .Off:
            self = .Low
        case .Low:
            self = .High
        case .High:
            self = .Off
    }
    }
}

var state = TriStateSwitch.Low // 必须使用var
state.next()
state.next()


protocol CustomStringConvertible {
    var description: String { get }
}

enum Trade1: CustomStringConvertible {
    case Buy, Sell
    var description: String {
        switch self {
        case .Buy:
            return "We're buying something"
        case .Sell:
            return "We're selling something"
    }
    }
}

let t1 = Trade1.Buy.description


protocol AccountCompatible {
    var remainingFunds: Int { get }
    mutating func addFunds(amount: Int) throws
    mutating func removeFunds(amount: Int) throws
}

enum Account {
    case Empty
    case Funds(remaining: Int)
    
    enum ErrorInfo: Error {
        case OverDraft(amount: Int)
    }
    
    var remainingFunds: Int {
        switch self {
        case .Empty:
            return 0
        case .Funds(let remaining):
            return remaining
    }
    }
}

extension Account: AccountCompatible {
    mutating func addFunds(amount: Int) throws {
        var newAmount = amount
        if case let .Funds(remaining) = self {
            newAmount += remaining
        }
        
        if newAmount < 0 {
            throw Account.ErrorInfo.OverDraft(amount: newAmount)
        }else if newAmount == 0 {
            self = .Empty
        }else {
            self = .Funds(remaining: newAmount)
        }
    }
    
    mutating func removeFunds(amount: Int) throws {
        try self.addFunds(amount: amount * -1)
    }
}

var account = Account.Funds(remaining: 20)
try? account.addFunds(amount: 20)
print("add: ", account.remainingFunds)
try? account.removeFunds(amount: 15)
print ("remove 1: ", account.remainingFunds)

do {
    try account.removeFunds(amount: 55)
}catch (let errorInfo)  {
    print(errorInfo)
}
print ("remove 2: ",  try? account.removeFunds(amount: 55))

来源：Swift 中枚举高级用法及实践
Advanced & Practical Enum usage in Swift