Swift：如何访问枚举的变量元素？

Question

For hours I've been struggeling with getting an variable element of an enum.

The " Swifticons " - pod provides me with the following enum:

public enum WeatherType: Int {
    static var count: Int {
        return weatherIcons.count
    }

    public var text: String? {
        return weatherIcons[rawValue]
    }

    case alien, barometer, celsius, owm300, owm301, owm302, and200moreOfTheseNames
}

private let weatherIcons = ["\u{f075}", "\u{f079}", and202moreOfTheseFontCharacters]

From an external API ( openWeatherMap.org ) I just get an weather code (let's say "300") - and I want to access Icon "owm300".

But how do I access this element of the enum without knowing the rawValue (which would be - say - 198)?

Answer 1

One of the easiest way I can think of is create some kind of mapping dictionary, where you would keep track of weather response code and WeatherType that it maps to like so,

let weatherCodeMapping: [Int: WeatherType] = [300: .owm300,
                                              301: .owm301,
                                              302: .owm302]

With this in place, you dont need to know any specific rawValue, you can simply get code by,

 let weatherType = weatherCodeMapping[weatherCode]

And then create some other mapping for your image based on the weatherType.

let weatherIcon = weatherIconMapping[weatherType]

or create a single mapping directly from weather code to icon.

Answer 2

Here's the plan:

1. We need to enumerate all of the enum cases. We'll do that by iterating over raw values (luckily, WeatherType is backed by Int ).
2. We will store lazily initialized dictionary that maps String to WeatherType .
3. And finally, we declare a static function that returns an optional WeatherType? because we can encounter an unknown value.

Here's the code:

extension WeatherType {
  // just some little convenience
  private typealias W = WeatherType

  // 1. define the sequence of all cases
  private static func allCases() -> AnySequence<W> {
    return AnySequence { () -> AnyIterator<W> in
      var raw = 0
      return AnyIterator {
        // Iterates while raw value can be converted to an enum case
        if let next = W(rawValue: raw) {
          raw += 1
          return next
        }
        return nil
      }
    }
  }

  // 2. Static properties are lazy so we'll use them to store the dictionary with String to WeatherType mapping
  private static let typeMap = W.allCases().reduce([String: W]()) { acc, next in
    var acc = acc
    acc[String(describing: next)] = next
    return acc
  }

  // 3. Declare the mapping function
  static func from(string: String) -> WeatherType? {
    return W.typeMap[string]
  }
}

Here's a little test:

let str = "301"
let type = WeatherType.from(string: "owm\(str)")
print(type == .owm301)

Answer 3

Swift doesn't currently have enumerable sequences of enum cases. One option that you have is to copy the list of icon names , then search for your icon's name, and use that index as the enum's rawValue:

let weatherIcons = [...]
let iconName = "owm300"
let possibleIconIndex = weatherIcons.index {
    $0.caseInsensitiveCompare(iconName) == .orderedSame
}
if let iconIndex = possibleIconIndex {
    let weatherIcon = WeatherIcon(rawValue: iconIndex)!
    // ...
} else {
    // graceful fallback for when the weather icon is missing
}

Of course, you need to figure out your own mapping between the data you get from the service and enum names, but that could be as simple as "owm\\(weatherCode)" .

When Swift 4.2 lands, you will be able to make your enums conform to a new protocol called CaseIterable . Enums that conform to it get a synthesized implementation of an allCases static variable. You will then be able to use that enumeration to build a string-to-enum dictionary automatically:

let nameToEnum = WeatherIcon.allCases.map { (String($0), $0) }
let mapping = Dictionary(uniqueKeysWithValues: nameToEnum)

That will however require WeatherIcon to be declared with the CaseEnumerable conformance, as adding it with an extension has no effect.