如何在特定類的Swift中聲明枚舉？

Question

我想創建一個類，並使用該類作爲我的新枚舉的類型，如下所示。

class Abc{ 
    var age = 25 
    var name = "Abhi" 
} 

enum TestEnum : Abc { 
    case firstCase 
    case secondCase 
} 

我在操場上出現錯誤。

error: raw type 'Abc' is not expressible by any literal 

所以我試圖符合RawRepresentable這樣的協議。

extension TestEnum : RawRepresentable{ 
    typealias RawValue = Abc 

    init?(rawValue:RawValue) { 
     switch rawValue { 
     case Abc.age : 
      self = .firstCase 

     case Abc.name : 
      self = .secondCase 
     } 
    } 

    var rawValue : RawValue { 
     switch self{ 

     case .firstCase : 
      return Abc.age 

     case .secondCase : 
      return Abc.name 
     } 
    } 
} 

我正在這之後以下錯誤：

error: raw type 'Abc' is not expressible by any literal 
error: instance member 'age' cannot be used on type 'Abc' 
error: instance member 'name' cannot be used on type 'Abc' 

什麼是定義類類型的枚舉，沒有得到明確這一點，思想的正確方法。任何人幫助？

Answer 1

從文檔

特別地，原始值類型必須符合Equatable 協議和以下協議之一： ExpressibleByIntegerLiteral爲整數常量， ExpressibleByFloatLiteral浮點文字， ExpressibleByStringLiteral對於包含字符的任何數字 的字符串文字，以及對於 僅包含單個字符的字符串文字，ExpressibleByUnicodeScalarLiteral或 ExpressibleByExtendedGraphemeClusterLiteral。

所以讓你的班級ABC符合Equatable和上述協議之一。下面是一個例子

public class Abc : Equatable,ExpressibleByStringLiteral{ 
    var age = 25 
    var name = "Abhi" 
    public static func == (lhs: Abc, rhs: Abc) -> Bool { 
     return (lhs.age == rhs.age && lhs.name == rhs.name) 
    } 
    public required init(stringLiteral value: String) { 
     let components = value.components(separatedBy: ",") 
     if components.count == 2 { 
      self.name = components[0] 
      if let age = Int(components[1]) { 
       self.age = age 
      } 
     } 
    } 
    public required convenience init(unicodeScalarLiteral value: String) { 
     self.init(stringLiteral: value) 
    } 
    public required convenience init(extendedGraphemeClusterLiteral value: String) { 
     self.init(stringLiteral: value) 
    } 
} 

enum TestEnum : Abc { 
    case firstCase = "Jack,29" 
    case secondCase = "Jill,26" 
} 

現在就可以初始化你枚舉像

let exEnum = TestEnum.firstCase 
print(exEnum.rawValue.name) // prints Jack 

Answer 2

我真的不知道你想實現什麼，但看看我的實現，辦法，我用在我的項目中：

class Abc { 
    var age: Int 
    var name: String 

    init(age: Int, name: String) { 
     self.age = age 
     self.name = name 
    } 
} 


enum TestEnum { 
    case firstCase 
    case secondCase 

    var instance: Abc { 
     switch self { 
     case .firstCase: return Abc(age: 25, name: "John") 
     case .secondCase: return Abc(age: 20, name: "Marry") 
     } 
    } 
} 

//Usage: 

let abc = TestEnum.secondCase.instance 
print(abc.age) //prints '20' 

Answer 3

看看Associated Values。 對於示例：

class Abc { 
    var age = 25 
    var name = "Abhi" 
} 

enum TestEnum { 
    case age(Int) 
    case name(String) 
} 

然後你可以使用它像這樣：

var person = Abc() 
... 
var value = TestEnum.age(person.age) 

switch value { 
    case .age(let age): 
     print("Age: \(age).") 
    case .name(let name): 
     print("Name: \(name).") 
} 

爲方便起見，你可以寫擴展枚舉，將您Abc對象，並將其轉換爲枚舉值：

static func fromAbc(_ object: Abc) -> TestEnum? { 
    if object.age { 
     return TestEnum.age(object.age) 
    } 

    if object.name { 
     return TestEnum.name(object.name) 
    } 

    return nil 
} 

注意：func fromAbc(object: Abc) -> TestEnum?你應該在如果的更換條件的東西，可以表示爲布爾（age > 0等）。

至於行值 - 在doc中指出，

原始值可以是字符串，字符或任何整數或浮點數類型。每個原始值在其枚舉聲明中必須是唯一的。

而且我不確定你可以在那裏適應課堂。