swift - 如何在类层次结构中应用 Swift 泛型/协议(protocol)？

Question

让我们从我要解决的问题开始。我正在将 XML 文档解析为模型对象的层次结构。所有模型对象都有一个带有一组公共(public)属性的公共(public)基类。然后每个特定的模型类都有一些额外的属性。

这是几个模型类的简化示例:

class Base {
    var id: String?
    var name: String?
    var children = [Base]()
}

class General: Base {
    var thing: String?
}

class Specific: General {
    var boring: String?
}

class Other: Base {
    var something: String?
    var another: String?
}

我有问题的部分是实现一种干净的方法来编写 XML 解析器类来处理这个模型层次结构。我正在尝试编写与模型层次结构匹配的解析器层次结构。这是我的尝试:

protocol ObjectParser {
    associatedtype ObjectType

    func createObject() -> ObjectType
    func parseAttributes(element: XMLElement, object: ObjectType)
    func parseElement(_ element: XMLElement) -> ObjectType
}

class BaseParser: ObjectParser {
    typealias ObjectType = Base

    var shouldParseChildren: Bool {
        return true
    }

    func createObject() -> Base {
        return Base()
    }

    func parseAttributes(element: XMLElement, object: Base) {
        object.id = element.attribute(forName: "id")?.stringValue
        object.name = element.attribute(forName: "name")?.stringValue
    }

    func parseChildren(_ element: XMLElement, parent: Base) {
        if let children = element.children {
            for child in children {
                if let elem = child as? XMLElement, let name = elem.name {
                    var parser: BaseParser? = nil

                    switch name {
                    case "general":
                        parser = GeneralParser()
                    case "specific":
                        parser = SpecificParser()
                    case "other":
                        parser = OtherParser()
                    default:
                        break
                    }

                    if let parser = parser {
                        let res = parser.parseElement(elem)
                        parent.children.append(res)
                    }
                }
            }
        }
    }

    func parseElement(_ element: XMLElement) -> Base {
        let res = createObject()

        parseAttributes(element: element, object: res)

        if shouldParseChildren {
            parseChildren(element, parent: res)
        }

        return res
    }
}

class GeneralParser: BaseParser {
    typealias ObjectType = General

    override func createObject() -> General {
        return General()
    }

    func parseAttributes(element: XMLElement, object: General) {
        super.parseAttributes(element: element, object: object)

        object.thing = element.attribute(forName: "thing")?.stringValue
    }
}

class SpecificParser: GeneralParser {
    typealias ObjectType = Specific

    override func createObject() -> Specific {
        return Specific()
    }

    func parseAttributes(element: XMLElement, object: Specific) {
        super.parseAttributes(element: element, object: object)

        object.boring = element.attribute(forName: "boring")?.stringValue
    }
}

还有OtherParser，它与GeneralParser 相同，只是将General 替换为Other。当然，在我的层次结构中还有更多的模型对象和关联的解析器。

这个版本的代码几乎可以工作。您会注意到 GeneralParser 和 SpecificParser 类中的 parseAttributes 方法没有覆盖。我认为这是由于 object 参数的类型不同所致。这样做的结果是，未从 BaseParser 的 parseElement 方法调用解析器特定的 parseAttributes 方法。我通过将所有 parseAttributes 签名更新为:

解决了这个问题

func parseAttributes(element: XMLElement, object: Base)

然后在非 Base 解析器中，我不得不使用强制转换(并添加 override，例如 GeneralParser 中的以下内容:

override func parseAttributes(element: XMLElement, object: Base) {
    super.parseAttributes(element: element, object: object)

    let general = object as! General
    general.thing = element.attribute(forName: "thing")?.stringValue
}

最后，问题:

如何消除 parseAttributes 方法层次结构中强制转换的需要并利用协议(protocol)的关联类型？更一般地说，这是解决这个问题的正确方法吗？有没有更“快捷”的方法来解决这个问题？

如果需要，这里有一些基于这个简化的对象模型的 XML:

<other id="top-level" name="Hi">
    <general thing="whatever">
        <specific boring="yes"/>
        <specific boring="probably"/>
        <other id="mid-level">
            <specific/>
        </other>
    </general>
</other>

Answer 1

下面是我将如何解决这个问题:

func createObject(from element: XMLElement) -> Base {
    switch element.name {
    case "base":
        let base = Base()
        initialize(base: base, from: element)
        return base
    case "general":
        let general = General()
        initialize(general: general, from: element)
        return general
    case "specific":
        let specific = Specific()
        initialize(specific: specific, from: element)
        return specific
    case "other":
        let other = Other()
        initialize(other: other, from: element)
        return other
    default:
        fatalError()
    }
}

func initialize(base: Base, from element: XMLElement) {
    base.id = element.attribute(forName: "id")?.stringValue
    base.name = element.attribute(forName: "name")?.stringValue
    base.children = element.children.map { createObject(from: $0) }
}

func initialize(general: General, from element: XMLElement) {
    general.thing = element.attribute(forName: "thing")?.stringValue
    initialize(base: general, from: element)
}

func initialize(specific: Specific, from element: XMLElement) {
    specific.boring = element.attribute(forName: "boring")?.stringValue
    initialize(general: specific, from: element)
}

func initialize(other: Other, from element: XMLElement) {
    other.something = element.attribute(forName: "something")?.stringValue
    other.another = element.attribute(forName: "another")?.stringValue
    initialize(base: other, from: element)
}

我真的不认为需要 Parser 类的镜像继承层次结构。我最初尝试将 initialize 函数作为扩展中的构造函数，但您不能覆盖扩展方法。当然，您可以将它们设为类本身的 init 方法，但我假设您希望将 XML 特定代码与您的模型代码分开。

-- 添加 --

I'd still love to know if there is a more general solution to the overall question of dealing with calling overloaded (not overridden) methods (like parseAttributes) from a base class in Swift.

您可以像使用任何其他语言一样进行操作。您转换对象(如有必要)，然后调用该方法。在这方面，Swift 没有什么神奇或特别的地方。

class Foo {
    func bar(with: Int) {
        print("bar with int called")
    }
}

class SubFoo: Foo {
    func bar(with: String) {
        print("bar with string called")
    }
}


let foo: Foo = SubFoo()

foo.bar(with: 12) // can't access bar(with: Double) here because foo is of type Foo
(foo as? SubFoo)?.bar(with: "hello") // (foo as? SubFoo)? will allow you to call the overload if foo is a SubFoo

let subFoo = SubFoo()

// can call either here
subFoo.bar(with: "hello")
subFoo.bar(with: 12)