Deserializing enums...

[woolie]

I have some XML that seems to be a really good fit for deserializing into an enum with associated values.

<NoteProperties>
    <Property name="ConcertPitch">
        <Pitch>
            <Step>G</Step>
            <Accidental>#</Accidental>
            <Octave>5</Octave>
        </Pitch>
    </Property>
    <Property name="Fret">
          <Fret>9</Fret>
    </Property>
    <Property name="Midi">
          <Number>68</Number>
    </Property>
    <Property name="String">
          <String>4</String>
    </Property>
    <Property name="TransposedPitch">
        <Pitch>
            <Step>G</Step>
            <Accidental>#</Accidental>
            <Octave>6</Octave>
        </Pitch>
    </Property>
</NoteProperties>

That seems like a good thing to deserialize into something like:

enum NoteProperty {
    case concertPitch(Pitch)
    case fret(Int)
    case Midi(Int)
    case String(Int)
    case TransposedPitch(Pitch)
}

Now, how might I do this with the deserialization process?

[woolie]

So, I went ahead and tried a few things:

enum NoteProperty: XMLIndexerDeserializable {
	case concertPitch(Pitch)
	case fret(Int)
	case midi(Int)
	case string(Int)
	case transposedPitch(Pitch)
	case harmonic(Bool)
	case harmonicFret(Float)
	case harmonicType(String)
	case hopoOrigin(Bool)
	case hopoDestination(Bool)
	case muted(Bool)
	case slide(Int)
	case bend(Bool)
	case bendDestinationOffset(Float)
	case bendDestinationValue(Float)
	case bendMiddleOffset1(Float)
	case bendMiddleOffset2(Float)
	case bendMiddleValue(Float)
	case bendOriginOffset(Float)
	case bendOriginValue(Float)

	static func deserialize(_ node: XMLIndexer) throws -> NoteProperty {
		let propertyAttribute: String = try node.value(ofAttribute: "name")

		switch propertyAttribute {
		case "ConcertPitch":
			return .concertPitch( Pitch(step: .e, accidental: .none, octave: 0) )
		case "Fret":                                   return .fret(try node["Fret"].value())
		case "Midi":                                   return .midi(try node["Number"].value())
		case "String":                                return .string(try node["String"].value())
 		case "TransposedPitch":
		case "Harmonic":                          return .harmonic(node["Enable"].element != nil)
		case "HarmonicFret":                   return .harmonicFret(try node["HFret"].value())
		case "HarmonicType":                  return .harmonicType(try node["HType"].value())
		case "BendDestinationOffset":    return .bendDestinationOffset(try node["Float"].value())
		case "BendDestinationValue":      return .bendDestinationValue(try node["Float"].value())
		default:
			throw NotePropertyParseError.unsupportedPropertyAttribute(propertyAttribute)
		}
	}
}

Which is a sketch of what might work. It seems to work, I was more wondering if there were established patterns.

[drmohundro]

That's a great question - I think what you've got makes sense, too. To be honest, in all this time, I've not deserialized into an enum... SWXMLHash itself uses enums a lot, but I haven't used them in code when pulling data back out. If you don't mind, I might point the FAQ to this discussion as there have been questions about deserializing to classes versus structs.

[woolie]

I do not mind at all. Maybe make a less edited version of what I put up there to match the rest of your samples.