通过父级属性动态解组子XML

Question

How do we dynamically unmarshal child XML with attributes from parent?

We have the the following XMLs:

<!-- Report I -->
<report type="YYYY-MM-DD">
  <created_at>2016-01-01</created_at>
</report>

<!-- Report II -->
<report type="DD-MM-YYYY">
  <created_at>01-01-2016</created_at>
</report>

And we have the following structure:

type Report struct {
  XMLName   xml.Name    `xml:"report"`
  Type      string      `xml:"type,attr"`
  CreatedAt *ReportDate `xml:"created_at"`
}

type ReportDate struct {
    time.Time
}

func (c *ReportDate) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    const format = "02-01-2006" // or "2016-01-02" depending on parent's "type"
    var v string
    d.DecodeElement(&v, &start)
    parse, err := time.Parse(format, v)
    if err != nil {
        return err
    }
    *c = ReportDate{parse}
    return nil
}

Will it be possible for ReportDate to obtain type="?" from it's parent in UnmarshalXML? Or will it be possible for Report to pass down attribute values to all child tags? If it is possible, how do we accomplish this?

Answer 1

While parsing the parent you can set a 'private' field within the child element that let's it know the time format string to use.

Here's a working example https://play.golang.org/p/CEqjWoDQR3.

And here's the code:

package main

import (
    "encoding/xml"
    "fmt"
    "io"
    "time"
)

// TypeMap converts the XML date format string to a valid Go date format string
var typeMap = map[string]string{
    "YYYY-MM-DD": "2006-01-02",
    "DD-MM-YYYY": "02-01-2006",
}

// Example XML documents
var reportStrings = []string{
    `<!-- Report I -->
<report type="YYYY-MM-DD">
  <created_at>2016-01-01</created_at>
</report>`,

    `<!-- Report II -->
<report type="DD-MM-YYYY">
  <created_at>01-01-2016</created_at>
</report>`,
}

type Report struct {
    XMLName   xml.Name   `xml:"report"`
    Type      string     `xml:"type,attr"`
    CreatedAt ReportDate `xml:"created_at"`
}

type ReportDate struct {
    dateFormatStr string // lower-case field is ignored by decoder/encoder

    Time time.Time
}

func (r *Report) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    for _, attr := range start.Attr {
        if attr.Name.Local == "type" {
            dateFormatStr, ok := typeMap[attr.Value]
            if !ok {
                return fmt.Errorf("unknown date type '%s'", attr.Value)
            }
            r.CreatedAt.dateFormatStr = dateFormatStr
        }
    }

    for {
        tok, err := d.Token()
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }
        switch tok.(type) {
        case xml.StartElement:
            nextStart := tok.(xml.StartElement)
            if nextStart.Name.Local == "created_at" {
                d.DecodeElement(&r.CreatedAt, &nextStart)
            }
        }
    }

    return nil
}

func (c *ReportDate) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
    var s string
    d.DecodeElement(&s, &start)
    t, err := time.Parse(c.dateFormatStr, s)
    if err != nil {
        return err
    }
    c.Time = t
    return nil
}

func main() {
    for i, reportStr := range reportStrings {
        var report Report
        if err := xml.Unmarshal([]byte(reportStr), &report); err != nil {
            panic(err)
        }

        fmt.Printf("[%d] %s
", i, report.CreatedAt.Time)
    }
}