ios - enum swift

Herencia Swift enum

Question

¿Puedes heredar enum en Swift? ¿Cuáles son las reglas que uno debe tener en cuenta con respecto a la herencia enum?

El siguiente código de prueba:

enum TemperatureUnit: Int {
case Kelvin, Celcius, Farenheit
}
enum TemperatureSubunit : Temperature {
}

genera

error: type ''TemperatureSubunit'' does not conform to protocol ''RawRepresentable''

Answer 1

Como Korpel ya respondió, actualmente no hay una herencia real admitida para los Enums. Por lo tanto, no es posible que cierto Enum se extienda y herede los casos de otra enumeración.

Sin embargo, agregaría que los Enume son compatibles con los protocolos, y junto con las extensiones de protocolo introducidas en Swift 2 y el nuevo enfoque de programación orientado al protocolo (vea este video ), es posible implementar algo que se asemeja a la herencia. Esta es una técnica que uso mucho para definir UITableViewController : s conducido por enumeraciones, para especificar las secciones de la tabla y las filas dentro de cada sección, y para agregar algún comportamiento útil. Ver por ejemplo el siguiente código de muestra:

import UIKit
protocol TableSection {
static var rows: [Self] { get }
var title: String { get }
var mandatoryField: Bool { get }
}
extension TableSection {
var mandatoryTitle: String {
if mandatoryField {
return "/(title)*"
} else {
return title
}
}
}
enum RegisterTableSection: Int, TableSection {
case Username
case Birthdate
case Password
case RepeatPassword
static var rows: [RegisterTableSection] {
return [.Username, .Password, .RepeatPassword]
}
var title: String {
switch self {
case .Username:
return "Username"
case .Birthdate:
return "Date of birth"
case .Password:
return "Password"
case .RepeatPassword:
return "Repeat password"
}
}
var mandatoryField: Bool {
switch self {
case .Username:
return true
case .Birthdate:
return false
case .Password:
return true
case .RepeatPassword:
return true
}
}
}
class ViewController: UITableViewController {
override func viewDidLoad() {
super.viewDidLoad()
}
override func numberOfSectionsInTableView(tableView: UITableView) -> Int {
return 1
}
override func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return RegisterTableSection.rows.count
}
override func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
guard let row = RegisterTableSection(rawValue: indexPath.row) else {
// This should never happen
return UITableViewCell()
}
let cell = UITableViewCell()
cell.textLabel?.text = row.mandatoryTitle
return cell
}
}

El código anterior representaría la siguiente tabla:

Observe cómo al implementar el protocolo, nuestra enumeración RegisterTableSection debe proporcionar implementaciones a los métodos y variables definidos en el protocolo. Y lo más interesante es que hereda una implementación predeterminada de la variable mandatoryTitle través de la extensión de protocolo TableSection

He cargado el código fuente de este ejemplo here

Answer 2

En lenguaje rápido, tenemos Structs, Enum y Classes. Struct y Enum son aprobados por copia, pero las clases se pasan por referencia. Solo las clases admiten herencia, Enum y Struct no. Por lo tanto, para responder a tu pregunta no puedes tener herencia con Enum (y tipos de Struct). Echa un vistazo aquí

clases de diferencia vs estructuras

Answer 3

Mira mi ejemplo, es mucho más fácil: ¿Puede una enumeración contener otros valores enum en Swift?

Idea

enum State {
case started
case succeeded
case failed
}
enum ActionState {
case state(value: State)
case cancelled
}

Resultado

La instancia de ActionState ahora tiene 4 valores:

.state(value: .started)
.state(value: .succeeded)
.state(value: .failed)
.cancelled

Otra muestra

import Foundation
enum StringCharactersTransformType {
case upperCase
case lowerCase
}
enum StringTransformType {
case state(value: StringCharactersTransformType)
case normal
static var upperCase: StringTransformType {
return .state(value: .upperCase)
}
static var lowerCase: StringTransformType {
return .state(value: .lowerCase)
}
}
var type = StringTransformType.normal
print(type)
type = .upperCase
print(type)
type = .lowerCase
print(type)

Resultado