错误：

Question

我已经编写了一个协议，允许链接一个简单链中的对象与前辈和后继者。

我尝试将此协议用于我的核心数据实体＆＃34;事件＆＃34;，但我收到此错误：

错误：

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 chain：[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子类实现的某些函数实现包装器

使Core Data类成为最终版以满足协议＆＃39; Self＆＃39;需求

错误：

1 个答案:

解决方法：