Bool, and Bool shortcuts in XML, best practices...

[woolie]

I was looking at some of my code that was failing. I was trying to support both<Boolean /> as well as potential values in <Boolean>xxx</Boolean> and even complete lack of either as well.

I can check to see if the node["Boolean"].element != nil, that will tell me whether Boolean was found at all in the node. But then I can't just say boolean = try node["Boolean"].value() on it since the shortcut version <Boolean /> will throw an exception with an empty value.

How do I distinguish the three potential variants?

1 - <Boolean />
2 - <Boolean>xxx</Boolean>
3 - nothing at all

Ideally I'd like to say let foo: Boolean? = node["Boolean"].value() and I'd get nil for case 3, and a value for the other two cases.

[woolie]

So, as I work through this, by the time <Boolean /> gets to my code, it has already been converted to <Boolean></Boolean>. Am I to assume that .text == "" and .text == "true" are the same?

[woolie]

And the crux of my misunderstanding here is that the code I was using to determine if <Boolean /> was there at all was doing:

(node["Boolean"].element != nil) ? true : false

This does not account for the case #2 above, and even worse, in case #3 I get an exception be .element isn't found. Hmmmm. I have a fundamental misunderstanding of this.

Any suggestions are welcome.

[woolie]

For now, I came up with an XMLIndexer extension to solve for this:

func value<T: XMLElementDeserializable>(found: T, notFound: T) throws -> T {
    switch self {
        case .element(let element):
        do {
            let deserialized = try T.deserialize(element)
            try deserialized.validate()
            return deserialized
        } catch XMLDeserializationError.nodeHasNoValue {
            return found
        }
        case .stream(_ /*let opStream*/):
            throw XMLDeserializationError.nodeIsInvalid(node: "Streaming Not Supported")
        case .xmlError(let indexingError):
            if case let .key(error) = indexingError, !error.isEmpty {
                return notFound
            } else {
                throw XMLDeserializationError.nodeIsInvalid(node: indexingError.description)
            }
        default:
            throw XMLDeserializationError.nodeIsInvalid(node: "Unexpected error deserializing XMLElement -> T")
    }
}

This solves the issue where I can call:

let boolean: Bool = try node["Boolean"].value(found: true, notFound: false)

And things work in all 3 cases as desired. I can't finish the case .stream(_ /*let opStream*/): case in that extension since findElements() is internal.

[drmohundro]

So, I guess I have some questions and notes...

In XML, quick note that there isn't a difference between <Boolean /> and <Boolean></Boolean>. Just for another view of it, check out https://codebeautify.org/xml-parser-online (see screenshot below):

So then, that means that the content of the Boolean element, if it exists, is empty string or a string with contents, but not null. XML doesn't have the concept of null. If the element doesn't exist, then the entire Boolean check will come back as null.

The typical way this is handled with SWXMLHash is with optionals, like so:

// required
let value: String = try parser["requiredElement"].value()

// optional
let value: String? = try parser["optionalElement"].value()

Does that help?