Enum krotek w Swift

Question

Czy możliwe jest utworzenie wyliczenia krotek w Swift?

Chciałbym zbudować coś takiego:

enum ErrorCode: (Int, String) { 
    case Generic_Error = (0, "Unknown") 
    case DB_Error = (909, "Database") 
} 

Ale to nie kompiluje ... Czy istnieje sposób, aby uzyskać podobny wynik?

Answer 1

Zależy od tego, co masz na myśli przez "podobny". Co mogę zrobić, to użyć struct z właściwości statycznych stałych:

struct Trouble { 
    static let Generic_Error = (0, "Unknown") 
    static let DB_Error = (909, "Database") 
} 

Teraz takie rzeczy Trouble.Generic_Error są użyteczne w całym kodzie.

Answer 2

można zrobić coś takiego, może:

enum ErrorCode { 
    case Generic_Error 
    case DB_Error 

    func values() -> (code: Int!, description: String?)! { 
     switch self { 
     case .Generic_Error: 
      return (0, "Unknown") 
     case .DB_Error: 
      return (909, "Database") 
     } 
    } 
} 

i można zrobić coś takiego później:

let errorCode: ErrorCode = ErrorCode.Generic_Error; 
if (errorCode.values().code == 0) { 
    // do the business here... 
} 

Answer 3

Swift wyliczenia nie można mieć krotek jako typ wartości surowca.

Alternatywne rozwiązania obejmują przechowywania kodu i wynikające z opisu, że:

enum ErrorCode: Int, CustomStringConvertible { 
    case Generic = 0 
    case DB = 909 

    var description: String { 
     switch self { 
     case .Generic: 
      return "Unknown" 
     case .DB: 
      return "Database" 
     } 
    } 
} 

... lub przechowywania wartości skojarzone z kodem i opisem w przypadkach wyliczeniowych się:

enum Error { 
    case Generic(Int, String) 
    case DB(Int, String) 
} 

Jeśli "Po prostu szukamy stałych wartości, tak samo działałaby sugestia @ matt dotycząca organizacji ich w ramach struct.

Answer 4

Utwórz wyliczenie jako Int.

Na przykład:

https://github.com/rhodgkins/SwiftHTTPStatusCodes/blob/master/Sources/HTTPStatusCodes.swift

Answer 5

Rozwiązanie podobne do @holex, ale zamiast funkcji można użyć var.

enum SomeType { 
    case type1 
    case type2 
    case type3 

    var typeNameAndDescription: (name: String, description: String) { 
     switch self { 
     case .type1: 
      return ("type1 name", "type1 description") 
     case .type2: 
      return ("type2 name", "type2 description") 
     case .type3: 
      return ("type3 name", "type3 description") 
     } 
    } 
} 

i później:

let myType = SomeType.type1 
let typeName = myType.typeNameAndDescription.name 
let typeDescription = myType.typeNameAndDescription.description 

Answer 6

Możesz odpowiadać RawRepresentable i używać (Int, String) jako Self.RawValue powiązanego typu.

enum ErrorCode: RawRepresentable { 
    case Generic_Error 
    case DB_Error 

    var rawValue: (Int, String) { 
     switch self { 
     case .Generic_Error: return (0, "Unknown") 
     case .DB_Error: return (909, "Database") 
     } 
    } 

    init?(rawValue: (Int, String)) { 
     switch rawValue { 
     case (0, "Unknown"): self = .Generic_Error 
     case (909, "Database"): self = .DB_Error 
     default: return nil 
     } 
    } 
}