如何在类层次结构中应用 Swift 泛型/协议？

Question

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

以下是几个模型类的简化示例：

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 方法没有override。我认为这是由于 object 参数的类型不同。这样做的结果是解析器特定的parseAttributes 方法没有被BaseParser 的parseElement 方法调用。我通过将所有 parseAttributes 签名更新为：

func parseAttributes(element: XMLElement, object: Base)

然后在非Base解析器中，我不得不使用强制转换（并在GeneralParser中添加override，如下所示：

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 方法层次结构中强制转换的需要并利用协议的关联类型？更一般地说，这是解决这个问题的正确方法吗？有没有更“Swift”的方式来解决这个问题？

如果需要，这里有一些基于这个简化对象模型的 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 特定代码与模型代码分开。

-- 添加--

我仍然很想知道是否有更通用的解决方案 处理调用重载（未覆盖）的总体问题 来自 Swift 基类的方法（如 parseAttributes）。

您的操作方式与使用任何其他语言的方式相同。您转换对象（如有必要），然后调用该方法。在这方面，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)