Die Core Data-Klasse als endgültig definieren, um das Protokoll 'Self' zu erfüllen

Question

Ich habe ein Protokoll geschrieben, das es erlaubt, Objekte in einer einfachen Kette mit Vorgänger und Nachfolgern zu verknüpfen.

Ich versuche, dieses Protokoll mit meinem Core Data Entity „Ereignis“ zu verwenden, aber ich bin immer diese Fehlermeldung:

Fehler:

Protocol 'Chainable' requirement 'chain' cannot be satisfied by a non-final class ('Event') because it uses 'Self' in a non-parameter, non-result type position. 

Wie kann ich diese Klasse macht final (Ich möchte Codegen nicht auf manuell setzen), oder schreibe die Var-Kette: [Self] Definition?

Vielen Dank im Voraus.

extension Event: Chainable {} 

protocol Chainable where Self: NSManagedObject { 

    var chain: [Self] { get } 

    var predecessor: Self? { get set } 
    var successor: Self? { get set } 

    var selfIndexInChain: Int { get } 

    mutating func moveInChain(to index: Int) 
    mutating func removeSelfFromChain() 

    mutating func addSelfAsSuccessor(of object: Self) 
    mutating func addSelfAsPredecessor(of object: Self) 
} 

extension Chainable { 

    var chain: [Self] { 

     var _chain: [Self] = [self] 

     // go right 
     var current: Self = self 
     while let successor = current.successor { 

      _chain.append(successor) 
      current = successor 
     } 

     // go left 
     current = self 
     while let predecessor = current.predecessor { 

      _chain.insert(predecessor, at: 0) 
      current = predecessor 
     } 

     // TODO: - Compare speed with the alternative realization: Find the first element, then populate the tasks array. 

     return _chain 
    } 

    // Self Index in the chain 
    var selfIndexInChain: Int { return self.chain.index(of: self)! } 


    // Change place in the cahain 
    mutating func moveInChain(to index: Int) { 

     guard index != selfIndexInChain else { return } // Check the index isn't same 
     guard 0...(chain.count-1) ~= index else { return } 

     let taskAtDestination = chain[index] 

     if index > selfIndexInChain { 

      removeSelfFromChain() 
      addSelfAsSuccessor(of: taskAtDestination) 
     } else { 
      removeSelfFromChain() 
      addSelfAsPredecessor(of: taskAtDestination) 
     } 
    } 

    mutating func removeSelfFromChain() { 

     let successor = self.successor 
     let predecessor = self.predecessor 

     self.predecessor = nil 
     self.successor = nil 

     self.predecessor?.successor = successor 
     self.successor?.predecessor = predecessor 
    } 

    mutating func insertSelfBetween(lhs: Self, rhs: Self) { 
     // self shouldn't be linked 
     guard self.predecessor == nil && self.successor == nil else { return } 

     guard (lhs.successor == rhs && rhs.predecessor == lhs) || 
      (lhs.successor == nil && rhs.predecessor == nil) else { return } // If both are nil, they will be connected thru self 

     self.predecessor = lhs 
     self.successor = rhs 

    } 

    mutating func addSelfAsSuccessor(of object: Self) { 
     // self shouldn't be linked 
     guard self.predecessor == nil && self.successor == nil else { return } // TODO: Add error support 
     // self shouldn't be already the successor 
     guard object.successor != self else { return } 

     let previousSuccessor = object.successor 
     self.predecessor = object 
     self.successor = previousSuccessor 

    } 

    mutating func addSelfAsPredecessor(of object: Self) { 
     // self shouldn't be linked 
     guard self.predecessor == nil && self.successor == nil else { return } 
     // self shouldn't be the task successor already 
     guard object.predecessor != self else { return } 

     let previousPredecessor = object.predecessor 
     self.successor = object 
     self.predecessor = previousPredecessor 
    } 

} 

Answer 1

Ich bin mit einem ähnlichen Problem wie auch stecken.

Umgehung:

auf dem Code der Suche, wie es scheint, Chainable würde durch eine Reihe von NSManagedObject Unterklassen implementiert werden.

Statt Self ersetzen Sie es durch Chainable und lassen Chainable die Mindestanforderungen enthalten, die mit den NSManagedObject Subklassen gemeinsam sein muss.

In einigen Fällen würde dies bedeuten, dass ein Wrapper für einige der von den NSManagedObject Unterklassen

implementierten Funktionen implementiert wird