unmarshal.go 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260
  1. package xmlutil
  2. import (
  3. "encoding/base64"
  4. "encoding/xml"
  5. "fmt"
  6. "io"
  7. "reflect"
  8. "strconv"
  9. "strings"
  10. "time"
  11. )
  12. // UnmarshalXML deserializes an xml.Decoder into the container v. V
  13. // needs to match the shape of the XML expected to be decoded.
  14. // If the shape doesn't match unmarshaling will fail.
  15. func UnmarshalXML(v interface{}, d *xml.Decoder, wrapper string) error {
  16. n, err := XMLToStruct(d, nil)
  17. if err != nil {
  18. return err
  19. }
  20. if n.Children != nil {
  21. for _, root := range n.Children {
  22. for _, c := range root {
  23. if wrappedChild, ok := c.Children[wrapper]; ok {
  24. c = wrappedChild[0] // pull out wrapped element
  25. }
  26. err = parse(reflect.ValueOf(v), c, "")
  27. if err != nil {
  28. if err == io.EOF {
  29. return nil
  30. }
  31. return err
  32. }
  33. }
  34. }
  35. return nil
  36. }
  37. return nil
  38. }
  39. // parse deserializes any value from the XMLNode. The type tag is used to infer the type, or reflect
  40. // will be used to determine the type from r.
  41. func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
  42. rtype := r.Type()
  43. if rtype.Kind() == reflect.Ptr {
  44. rtype = rtype.Elem() // check kind of actual element type
  45. }
  46. t := tag.Get("type")
  47. if t == "" {
  48. switch rtype.Kind() {
  49. case reflect.Struct:
  50. t = "structure"
  51. case reflect.Slice:
  52. t = "list"
  53. case reflect.Map:
  54. t = "map"
  55. }
  56. }
  57. switch t {
  58. case "structure":
  59. if field, ok := rtype.FieldByName("_"); ok {
  60. tag = field.Tag
  61. }
  62. return parseStruct(r, node, tag)
  63. case "list":
  64. return parseList(r, node, tag)
  65. case "map":
  66. return parseMap(r, node, tag)
  67. default:
  68. return parseScalar(r, node, tag)
  69. }
  70. }
  71. // parseStruct deserializes a structure and its fields from an XMLNode. Any nested
  72. // types in the structure will also be deserialized.
  73. func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
  74. t := r.Type()
  75. if r.Kind() == reflect.Ptr {
  76. if r.IsNil() { // create the structure if it's nil
  77. s := reflect.New(r.Type().Elem())
  78. r.Set(s)
  79. r = s
  80. }
  81. r = r.Elem()
  82. t = t.Elem()
  83. }
  84. // unwrap any payloads
  85. if payload := tag.Get("payload"); payload != "" {
  86. field, _ := t.FieldByName(payload)
  87. return parseStruct(r.FieldByName(payload), node, field.Tag)
  88. }
  89. for i := 0; i < t.NumField(); i++ {
  90. field := t.Field(i)
  91. if c := field.Name[0:1]; strings.ToLower(c) == c {
  92. continue // ignore unexported fields
  93. }
  94. // figure out what this field is called
  95. name := field.Name
  96. if field.Tag.Get("flattened") != "" && field.Tag.Get("locationNameList") != "" {
  97. name = field.Tag.Get("locationNameList")
  98. } else if locName := field.Tag.Get("locationName"); locName != "" {
  99. name = locName
  100. }
  101. // try to find the field by name in elements
  102. elems := node.Children[name]
  103. if elems == nil { // try to find the field in attributes
  104. if val, ok := node.findElem(name); ok {
  105. elems = []*XMLNode{{Text: val}}
  106. }
  107. }
  108. member := r.FieldByName(field.Name)
  109. for _, elem := range elems {
  110. err := parse(member, elem, field.Tag)
  111. if err != nil {
  112. return err
  113. }
  114. }
  115. }
  116. return nil
  117. }
  118. // parseList deserializes a list of values from an XML node. Each list entry
  119. // will also be deserialized.
  120. func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
  121. t := r.Type()
  122. if tag.Get("flattened") == "" { // look at all item entries
  123. mname := "member"
  124. if name := tag.Get("locationNameList"); name != "" {
  125. mname = name
  126. }
  127. if Children, ok := node.Children[mname]; ok {
  128. if r.IsNil() {
  129. r.Set(reflect.MakeSlice(t, len(Children), len(Children)))
  130. }
  131. for i, c := range Children {
  132. err := parse(r.Index(i), c, "")
  133. if err != nil {
  134. return err
  135. }
  136. }
  137. }
  138. } else { // flattened list means this is a single element
  139. if r.IsNil() {
  140. r.Set(reflect.MakeSlice(t, 0, 0))
  141. }
  142. childR := reflect.Zero(t.Elem())
  143. r.Set(reflect.Append(r, childR))
  144. err := parse(r.Index(r.Len()-1), node, "")
  145. if err != nil {
  146. return err
  147. }
  148. }
  149. return nil
  150. }
  151. // parseMap deserializes a map from an XMLNode. The direct children of the XMLNode
  152. // will also be deserialized as map entries.
  153. func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
  154. if r.IsNil() {
  155. r.Set(reflect.MakeMap(r.Type()))
  156. }
  157. if tag.Get("flattened") == "" { // look at all child entries
  158. for _, entry := range node.Children["entry"] {
  159. parseMapEntry(r, entry, tag)
  160. }
  161. } else { // this element is itself an entry
  162. parseMapEntry(r, node, tag)
  163. }
  164. return nil
  165. }
  166. // parseMapEntry deserializes a map entry from a XML node.
  167. func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
  168. kname, vname := "key", "value"
  169. if n := tag.Get("locationNameKey"); n != "" {
  170. kname = n
  171. }
  172. if n := tag.Get("locationNameValue"); n != "" {
  173. vname = n
  174. }
  175. keys, ok := node.Children[kname]
  176. values := node.Children[vname]
  177. if ok {
  178. for i, key := range keys {
  179. keyR := reflect.ValueOf(key.Text)
  180. value := values[i]
  181. valueR := reflect.New(r.Type().Elem()).Elem()
  182. parse(valueR, value, "")
  183. r.SetMapIndex(keyR, valueR)
  184. }
  185. }
  186. return nil
  187. }
  188. // parseScaller deserializes an XMLNode value into a concrete type based on the
  189. // interface type of r.
  190. //
  191. // Error is returned if the deserialization fails due to invalid type conversion,
  192. // or unsupported interface type.
  193. func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
  194. switch r.Interface().(type) {
  195. case *string:
  196. r.Set(reflect.ValueOf(&node.Text))
  197. return nil
  198. case []byte:
  199. b, err := base64.StdEncoding.DecodeString(node.Text)
  200. if err != nil {
  201. return err
  202. }
  203. r.Set(reflect.ValueOf(b))
  204. case *bool:
  205. v, err := strconv.ParseBool(node.Text)
  206. if err != nil {
  207. return err
  208. }
  209. r.Set(reflect.ValueOf(&v))
  210. case *int64:
  211. v, err := strconv.ParseInt(node.Text, 10, 64)
  212. if err != nil {
  213. return err
  214. }
  215. r.Set(reflect.ValueOf(&v))
  216. case *float64:
  217. v, err := strconv.ParseFloat(node.Text, 64)
  218. if err != nil {
  219. return err
  220. }
  221. r.Set(reflect.ValueOf(&v))
  222. case *time.Time:
  223. const ISO8601UTC = "2006-01-02T15:04:05Z"
  224. t, err := time.Parse(ISO8601UTC, node.Text)
  225. if err != nil {
  226. return err
  227. }
  228. r.Set(reflect.ValueOf(&t))
  229. default:
  230. return fmt.Errorf("unsupported value: %v (%s)", r.Interface(), r.Type())
  231. }
  232. return nil
  233. }