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。当然，我的层次结构中还有更多的模型对象和相关的解析器。

此版本的代码几乎可以使用。您会注意到override和parseAttributes类中的GeneralParser方法没有SpecificParser。我认为这是由于object参数的不同类型。结果是，未使用parseAttributes parseElement方法调用特定于解析器的BaseParser方法。我通过将所有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方法层次结构中消除强制转换的需要并使用协议的关联类型？更一般的说，这是解决这个问题的正确方法吗？还有更多＆＃34; Swift＆＃34;解决这个问题的方法？

如果需要，这里有一些基于此简化对象模型构成的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）。

您可以像使用任何其他语言一样进行操作。您转换对象（如有必要），然后调用该方法。在这方面，斯威夫特没有任何神奇或特殊的东西。

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)

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

1 个答案: