swift - ¿Cómo implementar correctamente el protocolo Equatable en una jerarquía de clases?

subclass swift3

Question

Estoy intentando implementar el operador == (de Equatable ) en una clase base y sus subclases en Swift 3. Todas las clases solo se usarán en Swift, por lo que no quiero involucrar a NSObject o el protocolo NSCopying .

Empecé con una clase base y una subclase:

class Base {
var x : Int
}
class Subclass : Base {
var y : String
}

Ahora quería agregar Equatable y el operador == a Base . Parece lo suficientemente simple. Copie la firma del operador == de la documentación:

class Base : Equatable {
var x : Int
static func == (lhs: Base, rhs: Base) -> Bool {
return lhs.x == rhs.x
}
}

Hasta aquí todo bien. Ahora para la subclase:

class Subclass : Base {
static override func == (lhs: Base, rhs: Base) -> Bool {
return true
}
}

Pero esto resulta en un error:

La función del operador anula una función de operador ''final''

DE ACUERDO. Después de investigar un poco (todavía estoy aprendiendo Swift 3), aprendo que la static puede reemplazarse con la class para indicar que el método de tipo puede ser anulado.

Así que intento cambiar la static a class en Base :

class Base : Equatable {
var x : Int
class func == (lhs: Base, rhs: Base) -> Bool {
return lhs.x == rhs.x
}
}

Pero eso da como resultado un nuevo error:

El operador ''=='' declarado en la clase no final ''Base'' debe ser ''final''

Ugh. Esto es mucho más complicado de lo que debería ser.

¿Cómo implemento el protocolo Equatable y el operador == correctamente en una clase base y una subclase?

Answer 1

Después de mucha investigación y algo de prueba y error, finalmente se me ocurrió una solución de trabajo. El primer paso fue mover el operador == desde dentro de la clase al alcance global. Esto corrigió los errores sobre static y final .

Para la clase base, esto se convirtió en:

func == (lhs: Base, rhs: Base) -> Bool {
return lhs.x == rhs.x
}
class Base : Equatable {
var x : Int
}

Y para la subclase:

func == (lhs: Subclass, rhs: Subclass) -> Bool {
return true
}
class Subclass : Base {
var y : String
}

Ahora, la única parte que queda es averiguar cómo llamar al operador == de la clase base desde el operador == de la subclase. Esto me llevó a la solución final:

func == (lhs: Subclass, rhs: Subclass) -> Bool {
if lhs as Base == rhs as Base {
if lhs.y == rhs.y {
return true
}
}
return false
}

Esa primera instrucción if resulta en una llamada al operador == en la clase base.

La solución definitiva:

Base.swift:

func == (lhs: Base, rhs: Base) -> Bool {
return lhs.x == rhs.x
}
class Base : Equatable {
var x : Int
}

Subclass.swift:

func == (lhs: Subclass, rhs: Subclass) -> Bool {
if lhs as Base == rhs as Base {
if lhs.y == rhs.y {
return true
}
}
return false
}
class Subclass : Base {
var y : String
}