親からの属性を持つ子XMLを動的に非整列化

Question

親からの属性を使用して子XMLを動的に非整列化するにはどうすればよいですか？

我々は、次の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> 

をそして、我々は、以下の構造：

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 
} 

それがUnmarshalXMLに親からtype="?"を得ることがReportDate可能でしょうか？または、Reportが属性値をすべての子タグに渡すことは可能でしょうか？可能であれば、どうやってこれを達成するのですか？

Answer 1

親を解析する際に、子要素内に「プライベート」フィールドを設定して、使用する時刻書式文字列を知ることができます。

ここには、実例https://play.golang.org/p/CEqjWoDQR3があります。

そしてここでコードは次のとおりです。

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\n", i, report.CreatedAt.Time) 
    } 
} 

Answer 2

あなたは（「名前」のように報告する多くの要素を追加した場合、私は

Golangのためのより多くの慣用的なものがありますかどうかわからないんだけど、...

https://play.golang.org/p/5VpzXM5F95

package main 

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

var typeMap = map[string]string{ 
    "YYYY-MM-DD": "2006-01-02", 
    "DD-MM-YYYY": "02-01-2006", 
} 

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

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

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

    Name  string  `xml:"name"` 
    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" { 
      r.Type = attr.Value 
      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) 
      local := nextStart.Name.Local 
      if local == "created_at" { 
       d.DecodeElement(&r.CreatedAt, &nextStart) 
      } else if local == "name" { 
       d.DecodeElement(&r.Name, &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] %v\n", i, report) 
    } 
}