1

我正在尝试在 Swift 中实现一个通用的享元模式。在我的代码中，我使用弱引用的弱引用字典。基本协议 ( Node) 只是有一个位置。更改位置会创建一个新的Node.

当不再有对给定享元的任何引用时，我在网上看到的实现不会尝试清理内容。

符合 的类Node可以使用 选择加入flyweighting Factory，它维护现有对象的字典。

  • 当一个值被释放时，散列函数会改变（参见 参考资料Weak<T>.hash(into:)）。那会破坏事情吗？
  • 将这些值设为无主并以某种方式从工厂中移除会更好deinit吗？我可以以通用的方式做到这一点吗？
  • 身份运算符===不能用于协议类型。我可以在测试中以某种方式解决这个问题吗？
  • 有没有更简单的方法来做到这一点？

完整的游乐场代码

import Foundation

protocol Node {
    // Immutable: changing the position returns a new node
    func position(_ p:CGPoint) -> Node
    func printAddress()
}

protocol HashableNode : class, Hashable, Node { }

struct Weak<T : HashableNode> : Hashable {
    static func == (lhs: Weak<T>, rhs: Weak<T>) -> Bool {
        return lhs.value == rhs.value
    }

    weak var value : T?

    func hash(into hasher: inout Hasher) {
        value?.hash(into: &hasher)
    }
}

class Factory<T:HashableNode> {
    var values = [Weak<T> : Weak<T>]()

    func make(_ proto: T) -> T {
        let w = Weak<T>(value: proto)
        if let v = values[w] {
            if let r = v.value {
                return r
            }
        }
        values[w] = w
        return proto
    }
}

class TestNode : HashableNode {

    deinit {
        print("TestNode deinit")
    }

    // Can I define equality and hash automatically?
    static func == (lhs: TestNode, rhs: TestNode) -> Bool {
        return lhs.p == rhs.p
    }

    func hash(into hasher: inout Hasher) {
        hasher.combine(p.x)
        hasher.combine(p.y)
    }


    let p:CGPoint

    init(p: CGPoint) {
        print("TestNode init")
        self.p = p
    }

    func position(_ p: CGPoint) -> Node {
        return testNodeFactory.make(TestNode(p: p))
    }

    func printAddress() {
        print(Unmanaged.passUnretained(self).toOpaque())
    }

}

let testNodeFactory = Factory<TestNode>()

func runTest() {

    let n0 = testNodeFactory.make(TestNode(p: CGPoint.zero))
    let n1 = testNodeFactory.make(TestNode(p: CGPoint.zero))

    assert(n0 === n1)

    n0.printAddress()
    n1.printAddress()

    let n2 = n0.position(CGPoint(x: 1, y: 1))

    n2.printAddress()

    // Doesn't compile:
    // Binary operator '!==' cannot be applied to operands of type 'Node' and 'TestNode'
    // assert(n2 !== n0)

}

runTest()
print("done!")
4

1 回答 1

2

这一行：

let n2 = n0.position(CGPoint(x: 1, y: 1))

此处调用的 position 方法返回 a Node，而不是TestNode您为n1and显式创建的 a n2。编译器不知道如何比较这两种类型。

您可以实现ComparableTestNode<->Node 或类型 cast n2 作为 TestNode

于 2019-07-18T01:10:04.977 回答