'Self'요구 사항을 충족하기 위해 코어 데이터 클래스를 최종으로 만들기

Question

전 체와 후속 제품과 간단한 체인의 오브젝트를 연결할 수있는 프로토콜을 작성했습니다.

내 핵심 데이터 엔티티 "이벤트"로이 프로토콜을 사용하려고 해요,하지만 난이 오류 받고 있어요 :

이

가 오류 :

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. 

이 어떻게 (이 클래스 final을 만들 수 있습니다 Codegen을 수동으로 설정하는 것을 원하지 않습니다.) 또는 var 체인을 다시 작성하십시오 : [Self] 정의?

미리 감사드립니다.

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

나는 비슷한 문제가 붙어있다.

해결 방법 : Chainable이 NSManagedObject 서브 클래스들에 의해 구현 될 것 같은

은 당신의 코드를 보면, 그것은 보인다.

대신 Self

는 Chainable로 교체하고 Chainable가 NSManagedObject 서브 클래스에 공통으로 필요한 최소 요구 사항을 포함 할 수 있습니다.

어떤 경우에는 NSManagedObject 서브 클래스

에 의해 구현 된 일부 기능에 대한 래퍼를 구현하는 것이 의미있는 경우도 있습니다.