Swift - Skojarzona wartość lub rozszerzenie dla Enum

Question

Ogólne pytanie dotyczące szybkiego wyliczania.

Chcę utworzyć enum z „ikoną” i „współpracownik” o wartości do sprawy enum

enum Icon { 
    case plane 
    case arrow 
    case logo 
    case flag 
} 

Chcę utworzyć skojarzony obraz do wartości wyliczenia za. A także skojarzony kolor do wartości enum

Tak na przykład, czy to możliwe, aby zrobić coś takiego:

extension Icon.plane { 
    var image = { 
    get { 
     return UIImage("plane.png") 
    } 
    } 
    var color = { 
    get { 
     return UIColor.greenColor() 
    } 
    } 
} 


var image = Icon.arrow.image // the image associated to the enum 
var color = Icon.arrow.color // the color associated to the enum 

Czy tego typu rzeczy możliwe?

Answer 1

Niestety nie można określić właściwości statycznych na podstawie przypadków enum, ale można użyć właściwości obliczone i switch do zwracania wartości dla każdego przypadku:

enum Icon { 
    case plane 
    case arrow 
    case logo 
    case flag 

    var image: UIImage { 
     switch self { 
      case .plane: return UIImage(named: "plane.png")! 
      case .arrow: return UIImage(named: "arrow.png")! 
      case .logo: return UIImage(named: "logo.png")! 
      case .flag: return UIImage(named: "flag.png")! 
     } 
    } 

    var color: UIColor { 
     switch self { 
     case .plane: return UIColor.greenColor() 
     case .arrow: return UIColor.greenColor() 
     case .logo: return UIColor.greenColor() 
     case .flag: return UIColor.greenColor() 
     } 
    } 
} 

// usage 
Icon.plane.color 

Answer 2

Używanie wyliczeń z powiązanymi wartościami w połączeniu z instrukcjami przełączania może być bardzo elastyczne. Pierwszy przykład:

enum Icon { 
    case plane(img:UIImage, col:UIColor) 
    case arrow(img:UIImage, col:UIColor) 
    case logo(img:UIImage, col:UIColor) 
    case flag(img:UIImage, col:UIColor) 

    var values:(img:UIImage,col:UIColor) { 
     switch self { 
     case let .plane(image, color): 
      return (image,color) 
     case let .arrow(image, color): 
      return (image,color) 
     case let .logo(image, color): 
      return (image,color) 
     case let .flag(image, color): 
      return (image,color) 
     } 
    } 
} 



var a = Icon.plane(img: UIImage(named: "image.png")!, col: UIColor.blueColor()) 

a.values.col 
a.values.img 

i drugi przykład:

enum Icon { 
    case plane(img:UIImage, col:UIColor) 
    case arrow(img:UIImage, col:UIColor) 
    case logo(img:UIImage, col:UIColor) 
    case flag(img:UIImage, col:UIColor) 

    var img:UIImage { 
     switch self { 
     case let .plane(image, color): 
      return image 
     case let .arrow(image, color): 
      return image 
     case let .logo(image, color): 
      return image 
     case let .flag(image, color): 
      return image 
     } 
    } 

    var col:UIColor { 
     switch self { 
     case let .plane(image, color): 
      return color 
     case let .arrow(image, color): 
      return color 
     case let .logo(image, color): 
      return color 
     case let .flag(image, color): 
      return color 
     } 
    } 
} 



var a = Icon.plane(img: UIImage(named: "image.png")!, col: UIColor.blueColor()) 

a.col 
a.img 

ma potrzeby rozszerzeń. A jeśli naprawdę chcesz wartości statyczne, można to zrobić:

struct MyIcon { 
    static let plane = Icon.plane(img: UIImage(named: "image.png")!, col: UIColor.blueColor()) 
    static let arrow = Icon.arrow(img: UIImage(named: "image.png")!, col: UIColor.blueColor()) 
    static let logo = Icon.logo(img: UIImage(named: "image.png")!, col: UIColor.blueColor()) 
    static let flag = Icon.flag(img: UIImage(named: "image.png")!, col: UIColor.blueColor()) 
} 

MyIcon.arrow.col 

które mogą być porządniej niż umieszczanie wartości stałych dosłownych wewnątrz instrukcji switch.