You have to model your XML structure with Go structs.
For elements which may have varying content (child elements), one option is to list all possible variations, and only the encountered element will be unmarshaled.
Your XML structure can be modeled like this:
type Venue struct {
As []A `xml:"c>a"`
}
type A struct {
N string `xml:"n,attr"`
I I `xml:"i"`
B B `xml:"b"`
}
type I struct {
I int `xml:",chardata"`
}
type B struct {
V bool `xml:"v,attr"`
}
And code to unmarshal the XML document:
func main() {
var v Venue
err := xml.Unmarshal([]byte(data), &v)
fmt.Printf("%+v %v", v, err)
}
const data = `<?xml version="1.0"?>
<!DOCTYPE venue SYSTEM "z.dtd">
<venue>
<c>
<a n="k1"><i>1</i></a>
<a n="k2"><b v="f"/></a>
</c>
</venue>`
Output (try it on the Go Playground):
{As:[{N:k1 I:{I:1} B:{V:false}} {N:k2 I:{I:0} B:{V:false}}]} <nil>
As you can see, the first element of the Venue.As
slice has A.N=k1
, and it has the A.I.I=1
value, which was taken from the XML.
The second element of the Venue.As
slice has A.N=k2
, and it has the A.B.V=false
value, taken from the XML.
If it bothers you that the "wrapper" A
struct contains both the I
and the B
fields (even though only one of them contains valid data), you may declare them to be pointers, and the one that is not present in the XML will be nil
(making it obvious and easy to tell which element was present in the XML):
type A struct {
N string `xml:"n,attr"`
I *I `xml:"i"`
B *B `xml:"b"`
}
Output this time (try it on the Go Playground):
{As:[{N:k1 I:0x1050e24c B:<nil>} {N:k2 I:<nil> B:0x1050e2f5}]} <nil>