Swift - How to get Raw Value from ENUM - ios

Question

I have the following enum:
enum MembershipLevel: Int {
case basic = 25
case bronze = 50
case silver = 100
case gold = 500
case platinum = 1000
}
which then I have the following firebase lookup:
userRef.child(userId).child("memeberlevel").observeSingleEvent(of: .value, with: { (snapshot) in
self.userRef.child(userId).child("count").observeSingleEvent(of: .value, with: { (snap) in
if((snap.value!) < MembershipLevel.(snapshot.value!).rawValue) {
completion(false)
} else {
completion(true)
}
})
})
The code above throws a complier error due to the following code:
MembershipLevel.(snapshot.value).rawValue
How can I reference the enum values dynamically, since the code snippet MembershipLevel.basic.rawValue is perfectly OK?

Answer 1

You should not use an enum here. Enum cases cannot be referred to dynamically.
While you could do something like this:
enum MembershipLevel: Int, CaseIterable {
case basic = 25
case bronze = 50
case silver = 100
case gold = 500
case platinum = 1000
init?(string: String) {
if let value = MembershipLevel.allCases.first(where: { "\($0)" == string }) {
self = value
} else {
return nil
}
}
}
// usage:
let userValue = snapValue.value as! Int
let membershipString = snapshot.value as! String
if userValue < MembershipLevel(string: membershipString)!.rawValue {
}
It might break in the future as I don't think "\($0)" producing the enum case name is guaranteed.
I would use a dictionary:
let membershipLevelNameDict = [
"basic": 25,
"bronze": 50,
"silver": 100,
"gold": 500,
"platinum": 1000
]
Usage:
let userValue = snapValue.value as! Int
let membershipString = snapshot.value as! String
if userValue < membershipLevelNameDict[membershipString] ?? 0 {
}
Using this dictionary, you can also create an instance of your enum:
membershipLevelNameDict[membershipString].flatMap(MembershipLevel.init(rawValue:))
But if you want to compare the raw values, just access the dictionary directly like in the first snippet.

Answer 2

You can make your enumeration conform to Comparable protocol and create an initializer that takes an Int:
extension MembershipLevel: Comparable {
init?(_ value: Any?) {
switch value {
case let int as Int:
self.init(rawValue: int)
case let string as String:
switch string {
case "basic": self = .basic
case "bronze": self = .bronze
case "silver": self = .silver
case "gold": self = .gold
case "platinum": self = .platinum
default: return nil
}
default: return nil
}
}
static func < (lhs: Self, rhs: Self) -> Bool {
lhs.rawValue < rhs.rawValue
}
}
Now you can initialize your enumeration from the snapshot values and compare them directly
if let lhs = MembershipLevel(snap.value),
let rhs = MembershipLevel(snapshot.value),
lhs < rhs {
completion(false)
}
} else {
completion(true)
}