...

Source file src/encoding/xml/read.go

Documentation: encoding/xml

     1  // Copyright 2009 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package xml
     6  
     7  import (
     8  	"bytes"
     9  	"encoding"
    10  	"errors"
    11  	"fmt"
    12  	"reflect"
    13  	"strconv"
    14  	"strings"
    15  )
    16  
    17  // BUG(rsc): Mapping between XML elements and data structures is inherently flawed:
    18  // an XML element is an order-dependent collection of anonymous
    19  // values, while a data structure is an order-independent collection
    20  // of named values.
    21  // See package json for a textual representation more suitable
    22  // to data structures.
    23  
    24  // Unmarshal parses the XML-encoded data and stores the result in
    25  // the value pointed to by v, which must be an arbitrary struct,
    26  // slice, or string. Well-formed data that does not fit into v is
    27  // discarded.
    28  //
    29  // Because Unmarshal uses the reflect package, it can only assign
    30  // to exported (upper case) fields. Unmarshal uses a case-sensitive
    31  // comparison to match XML element names to tag values and struct
    32  // field names.
    33  //
    34  // Unmarshal maps an XML element to a struct using the following rules.
    35  // In the rules, the tag of a field refers to the value associated with the
    36  // key 'xml' in the struct field's tag (see the example above).
    37  //
    38  //   * If the struct has a field of type []byte or string with tag
    39  //      ",innerxml", Unmarshal accumulates the raw XML nested inside the
    40  //      element in that field. The rest of the rules still apply.
    41  //
    42  //   * If the struct has a field named XMLName of type Name,
    43  //      Unmarshal records the element name in that field.
    44  //
    45  //   * If the XMLName field has an associated tag of the form
    46  //      "name" or "namespace-URL name", the XML element must have
    47  //      the given name (and, optionally, name space) or else Unmarshal
    48  //      returns an error.
    49  //
    50  //   * If the XML element has an attribute whose name matches a
    51  //      struct field name with an associated tag containing ",attr" or
    52  //      the explicit name in a struct field tag of the form "name,attr",
    53  //      Unmarshal records the attribute value in that field.
    54  //
    55  //   * If the XML element has an attribute not handled by the previous
    56  //      rule and the struct has a field with an associated tag containing
    57  //      ",any,attr", Unmarshal records the attribute value in the first
    58  //      such field.
    59  //
    60  //   * If the XML element contains character data, that data is
    61  //      accumulated in the first struct field that has tag ",chardata".
    62  //      The struct field may have type []byte or string.
    63  //      If there is no such field, the character data is discarded.
    64  //
    65  //   * If the XML element contains comments, they are accumulated in
    66  //      the first struct field that has tag ",comment".  The struct
    67  //      field may have type []byte or string. If there is no such
    68  //      field, the comments are discarded.
    69  //
    70  //   * If the XML element contains a sub-element whose name matches
    71  //      the prefix of a tag formatted as "a" or "a>b>c", unmarshal
    72  //      will descend into the XML structure looking for elements with the
    73  //      given names, and will map the innermost elements to that struct
    74  //      field. A tag starting with ">" is equivalent to one starting
    75  //      with the field name followed by ">".
    76  //
    77  //   * If the XML element contains a sub-element whose name matches
    78  //      a struct field's XMLName tag and the struct field has no
    79  //      explicit name tag as per the previous rule, unmarshal maps
    80  //      the sub-element to that struct field.
    81  //
    82  //   * If the XML element contains a sub-element whose name matches a
    83  //      field without any mode flags (",attr", ",chardata", etc), Unmarshal
    84  //      maps the sub-element to that struct field.
    85  //
    86  //   * If the XML element contains a sub-element that hasn't matched any
    87  //      of the above rules and the struct has a field with tag ",any",
    88  //      unmarshal maps the sub-element to that struct field.
    89  //
    90  //   * An anonymous struct field is handled as if the fields of its
    91  //      value were part of the outer struct.
    92  //
    93  //   * A struct field with tag "-" is never unmarshaled into.
    94  //
    95  // If Unmarshal encounters a field type that implements the Unmarshaler
    96  // interface, Unmarshal calls its UnmarshalXML method to produce the value from
    97  // the XML element.  Otherwise, if the value implements
    98  // encoding.TextUnmarshaler, Unmarshal calls that value's UnmarshalText method.
    99  //
   100  // Unmarshal maps an XML element to a string or []byte by saving the
   101  // concatenation of that element's character data in the string or
   102  // []byte. The saved []byte is never nil.
   103  //
   104  // Unmarshal maps an attribute value to a string or []byte by saving
   105  // the value in the string or slice.
   106  //
   107  // Unmarshal maps an attribute value to an Attr by saving the attribute,
   108  // including its name, in the Attr.
   109  //
   110  // Unmarshal maps an XML element or attribute value to a slice by
   111  // extending the length of the slice and mapping the element or attribute
   112  // to the newly created value.
   113  //
   114  // Unmarshal maps an XML element or attribute value to a bool by
   115  // setting it to the boolean value represented by the string. Whitespace
   116  // is trimmed and ignored.
   117  //
   118  // Unmarshal maps an XML element or attribute value to an integer or
   119  // floating-point field by setting the field to the result of
   120  // interpreting the string value in decimal. There is no check for
   121  // overflow. Whitespace is trimmed and ignored.
   122  //
   123  // Unmarshal maps an XML element to a Name by recording the element
   124  // name.
   125  //
   126  // Unmarshal maps an XML element to a pointer by setting the pointer
   127  // to a freshly allocated value and then mapping the element to that value.
   128  //
   129  // A missing element or empty attribute value will be unmarshaled as a zero value.
   130  // If the field is a slice, a zero value will be appended to the field. Otherwise, the
   131  // field will be set to its zero value.
   132  func Unmarshal(data []byte, v interface{}) error {
   133  	return NewDecoder(bytes.NewReader(data)).Decode(v)
   134  }
   135  
   136  // Decode works like Unmarshal, except it reads the decoder
   137  // stream to find the start element.
   138  func (d *Decoder) Decode(v interface{}) error {
   139  	return d.DecodeElement(v, nil)
   140  }
   141  
   142  // DecodeElement works like Unmarshal except that it takes
   143  // a pointer to the start XML element to decode into v.
   144  // It is useful when a client reads some raw XML tokens itself
   145  // but also wants to defer to Unmarshal for some elements.
   146  func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error {
   147  	val := reflect.ValueOf(v)
   148  	if val.Kind() != reflect.Ptr {
   149  		return errors.New("non-pointer passed to Unmarshal")
   150  	}
   151  	return d.unmarshal(val.Elem(), start)
   152  }
   153  
   154  // An UnmarshalError represents an error in the unmarshaling process.
   155  type UnmarshalError string
   156  
   157  func (e UnmarshalError) Error() string { return string(e) }
   158  
   159  // Unmarshaler is the interface implemented by objects that can unmarshal
   160  // an XML element description of themselves.
   161  //
   162  // UnmarshalXML decodes a single XML element
   163  // beginning with the given start element.
   164  // If it returns an error, the outer call to Unmarshal stops and
   165  // returns that error.
   166  // UnmarshalXML must consume exactly one XML element.
   167  // One common implementation strategy is to unmarshal into
   168  // a separate value with a layout matching the expected XML
   169  // using d.DecodeElement, and then to copy the data from
   170  // that value into the receiver.
   171  // Another common strategy is to use d.Token to process the
   172  // XML object one token at a time.
   173  // UnmarshalXML may not use d.RawToken.
   174  type Unmarshaler interface {
   175  	UnmarshalXML(d *Decoder, start StartElement) error
   176  }
   177  
   178  // UnmarshalerAttr is the interface implemented by objects that can unmarshal
   179  // an XML attribute description of themselves.
   180  //
   181  // UnmarshalXMLAttr decodes a single XML attribute.
   182  // If it returns an error, the outer call to Unmarshal stops and
   183  // returns that error.
   184  // UnmarshalXMLAttr is used only for struct fields with the
   185  // "attr" option in the field tag.
   186  type UnmarshalerAttr interface {
   187  	UnmarshalXMLAttr(attr Attr) error
   188  }
   189  
   190  // receiverType returns the receiver type to use in an expression like "%s.MethodName".
   191  func receiverType(val interface{}) string {
   192  	t := reflect.TypeOf(val)
   193  	if t.Name() != "" {
   194  		return t.String()
   195  	}
   196  	return "(" + t.String() + ")"
   197  }
   198  
   199  // unmarshalInterface unmarshals a single XML element into val.
   200  // start is the opening tag of the element.
   201  func (d *Decoder) unmarshalInterface(val Unmarshaler, start *StartElement) error {
   202  	// Record that decoder must stop at end tag corresponding to start.
   203  	d.pushEOF()
   204  
   205  	d.unmarshalDepth++
   206  	err := val.UnmarshalXML(d, *start)
   207  	d.unmarshalDepth--
   208  	if err != nil {
   209  		d.popEOF()
   210  		return err
   211  	}
   212  
   213  	if !d.popEOF() {
   214  		return fmt.Errorf("xml: %s.UnmarshalXML did not consume entire <%s> element", receiverType(val), start.Name.Local)
   215  	}
   216  
   217  	return nil
   218  }
   219  
   220  // unmarshalTextInterface unmarshals a single XML element into val.
   221  // The chardata contained in the element (but not its children)
   222  // is passed to the text unmarshaler.
   223  func (d *Decoder) unmarshalTextInterface(val encoding.TextUnmarshaler) error {
   224  	var buf []byte
   225  	depth := 1
   226  	for depth > 0 {
   227  		t, err := d.Token()
   228  		if err != nil {
   229  			return err
   230  		}
   231  		switch t := t.(type) {
   232  		case CharData:
   233  			if depth == 1 {
   234  				buf = append(buf, t...)
   235  			}
   236  		case StartElement:
   237  			depth++
   238  		case EndElement:
   239  			depth--
   240  		}
   241  	}
   242  	return val.UnmarshalText(buf)
   243  }
   244  
   245  // unmarshalAttr unmarshals a single XML attribute into val.
   246  func (d *Decoder) unmarshalAttr(val reflect.Value, attr Attr) error {
   247  	if val.Kind() == reflect.Ptr {
   248  		if val.IsNil() {
   249  			val.Set(reflect.New(val.Type().Elem()))
   250  		}
   251  		val = val.Elem()
   252  	}
   253  	if val.CanInterface() && val.Type().Implements(unmarshalerAttrType) {
   254  		// This is an unmarshaler with a non-pointer receiver,
   255  		// so it's likely to be incorrect, but we do what we're told.
   256  		return val.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
   257  	}
   258  	if val.CanAddr() {
   259  		pv := val.Addr()
   260  		if pv.CanInterface() && pv.Type().Implements(unmarshalerAttrType) {
   261  			return pv.Interface().(UnmarshalerAttr).UnmarshalXMLAttr(attr)
   262  		}
   263  	}
   264  
   265  	// Not an UnmarshalerAttr; try encoding.TextUnmarshaler.
   266  	if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
   267  		// This is an unmarshaler with a non-pointer receiver,
   268  		// so it's likely to be incorrect, but we do what we're told.
   269  		return val.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
   270  	}
   271  	if val.CanAddr() {
   272  		pv := val.Addr()
   273  		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
   274  			return pv.Interface().(encoding.TextUnmarshaler).UnmarshalText([]byte(attr.Value))
   275  		}
   276  	}
   277  
   278  	if val.Type().Kind() == reflect.Slice && val.Type().Elem().Kind() != reflect.Uint8 {
   279  		// Slice of element values.
   280  		// Grow slice.
   281  		n := val.Len()
   282  		val.Set(reflect.Append(val, reflect.Zero(val.Type().Elem())))
   283  
   284  		// Recur to read element into slice.
   285  		if err := d.unmarshalAttr(val.Index(n), attr); err != nil {
   286  			val.SetLen(n)
   287  			return err
   288  		}
   289  		return nil
   290  	}
   291  
   292  	if val.Type() == attrType {
   293  		val.Set(reflect.ValueOf(attr))
   294  		return nil
   295  	}
   296  
   297  	return copyValue(val, []byte(attr.Value))
   298  }
   299  
   300  var (
   301  	attrType            = reflect.TypeOf(Attr{})
   302  	unmarshalerType     = reflect.TypeOf((*Unmarshaler)(nil)).Elem()
   303  	unmarshalerAttrType = reflect.TypeOf((*UnmarshalerAttr)(nil)).Elem()
   304  	textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem()
   305  )
   306  
   307  // Unmarshal a single XML element into val.
   308  func (d *Decoder) unmarshal(val reflect.Value, start *StartElement) error {
   309  	// Find start element if we need it.
   310  	if start == nil {
   311  		for {
   312  			tok, err := d.Token()
   313  			if err != nil {
   314  				return err
   315  			}
   316  			if t, ok := tok.(StartElement); ok {
   317  				start = &t
   318  				break
   319  			}
   320  		}
   321  	}
   322  
   323  	// Load value from interface, but only if the result will be
   324  	// usefully addressable.
   325  	if val.Kind() == reflect.Interface && !val.IsNil() {
   326  		e := val.Elem()
   327  		if e.Kind() == reflect.Ptr && !e.IsNil() {
   328  			val = e
   329  		}
   330  	}
   331  
   332  	if val.Kind() == reflect.Ptr {
   333  		if val.IsNil() {
   334  			val.Set(reflect.New(val.Type().Elem()))
   335  		}
   336  		val = val.Elem()
   337  	}
   338  
   339  	if val.CanInterface() && val.Type().Implements(unmarshalerType) {
   340  		// This is an unmarshaler with a non-pointer receiver,
   341  		// so it's likely to be incorrect, but we do what we're told.
   342  		return d.unmarshalInterface(val.Interface().(Unmarshaler), start)
   343  	}
   344  
   345  	if val.CanAddr() {
   346  		pv := val.Addr()
   347  		if pv.CanInterface() && pv.Type().Implements(unmarshalerType) {
   348  			return d.unmarshalInterface(pv.Interface().(Unmarshaler), start)
   349  		}
   350  	}
   351  
   352  	if val.CanInterface() && val.Type().Implements(textUnmarshalerType) {
   353  		return d.unmarshalTextInterface(val.Interface().(encoding.TextUnmarshaler))
   354  	}
   355  
   356  	if val.CanAddr() {
   357  		pv := val.Addr()
   358  		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
   359  			return d.unmarshalTextInterface(pv.Interface().(encoding.TextUnmarshaler))
   360  		}
   361  	}
   362  
   363  	var (
   364  		data         []byte
   365  		saveData     reflect.Value
   366  		comment      []byte
   367  		saveComment  reflect.Value
   368  		saveXML      reflect.Value
   369  		saveXMLIndex int
   370  		saveXMLData  []byte
   371  		saveAny      reflect.Value
   372  		sv           reflect.Value
   373  		tinfo        *typeInfo
   374  		err          error
   375  	)
   376  
   377  	switch v := val; v.Kind() {
   378  	default:
   379  		return errors.New("unknown type " + v.Type().String())
   380  
   381  	case reflect.Interface:
   382  		// TODO: For now, simply ignore the field. In the near
   383  		//       future we may choose to unmarshal the start
   384  		//       element on it, if not nil.
   385  		return d.Skip()
   386  
   387  	case reflect.Slice:
   388  		typ := v.Type()
   389  		if typ.Elem().Kind() == reflect.Uint8 {
   390  			// []byte
   391  			saveData = v
   392  			break
   393  		}
   394  
   395  		// Slice of element values.
   396  		// Grow slice.
   397  		n := v.Len()
   398  		v.Set(reflect.Append(val, reflect.Zero(v.Type().Elem())))
   399  
   400  		// Recur to read element into slice.
   401  		if err := d.unmarshal(v.Index(n), start); err != nil {
   402  			v.SetLen(n)
   403  			return err
   404  		}
   405  		return nil
   406  
   407  	case reflect.Bool, reflect.Float32, reflect.Float64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.String:
   408  		saveData = v
   409  
   410  	case reflect.Struct:
   411  		typ := v.Type()
   412  		if typ == nameType {
   413  			v.Set(reflect.ValueOf(start.Name))
   414  			break
   415  		}
   416  
   417  		sv = v
   418  		tinfo, err = getTypeInfo(typ)
   419  		if err != nil {
   420  			return err
   421  		}
   422  
   423  		// Validate and assign element name.
   424  		if tinfo.xmlname != nil {
   425  			finfo := tinfo.xmlname
   426  			if finfo.name != "" && finfo.name != start.Name.Local {
   427  				return UnmarshalError("expected element type <" + finfo.name + "> but have <" + start.Name.Local + ">")
   428  			}
   429  			if finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
   430  				e := "expected element <" + finfo.name + "> in name space " + finfo.xmlns + " but have "
   431  				if start.Name.Space == "" {
   432  					e += "no name space"
   433  				} else {
   434  					e += start.Name.Space
   435  				}
   436  				return UnmarshalError(e)
   437  			}
   438  			fv := finfo.value(sv)
   439  			if _, ok := fv.Interface().(Name); ok {
   440  				fv.Set(reflect.ValueOf(start.Name))
   441  			}
   442  		}
   443  
   444  		// Assign attributes.
   445  		for _, a := range start.Attr {
   446  			handled := false
   447  			any := -1
   448  			for i := range tinfo.fields {
   449  				finfo := &tinfo.fields[i]
   450  				switch finfo.flags & fMode {
   451  				case fAttr:
   452  					strv := finfo.value(sv)
   453  					if a.Name.Local == finfo.name && (finfo.xmlns == "" || finfo.xmlns == a.Name.Space) {
   454  						if err := d.unmarshalAttr(strv, a); err != nil {
   455  							return err
   456  						}
   457  						handled = true
   458  					}
   459  
   460  				case fAny | fAttr:
   461  					if any == -1 {
   462  						any = i
   463  					}
   464  				}
   465  			}
   466  			if !handled && any >= 0 {
   467  				finfo := &tinfo.fields[any]
   468  				strv := finfo.value(sv)
   469  				if err := d.unmarshalAttr(strv, a); err != nil {
   470  					return err
   471  				}
   472  			}
   473  		}
   474  
   475  		// Determine whether we need to save character data or comments.
   476  		for i := range tinfo.fields {
   477  			finfo := &tinfo.fields[i]
   478  			switch finfo.flags & fMode {
   479  			case fCDATA, fCharData:
   480  				if !saveData.IsValid() {
   481  					saveData = finfo.value(sv)
   482  				}
   483  
   484  			case fComment:
   485  				if !saveComment.IsValid() {
   486  					saveComment = finfo.value(sv)
   487  				}
   488  
   489  			case fAny, fAny | fElement:
   490  				if !saveAny.IsValid() {
   491  					saveAny = finfo.value(sv)
   492  				}
   493  
   494  			case fInnerXml:
   495  				if !saveXML.IsValid() {
   496  					saveXML = finfo.value(sv)
   497  					if d.saved == nil {
   498  						saveXMLIndex = 0
   499  						d.saved = new(bytes.Buffer)
   500  					} else {
   501  						saveXMLIndex = d.savedOffset()
   502  					}
   503  				}
   504  			}
   505  		}
   506  	}
   507  
   508  	// Find end element.
   509  	// Process sub-elements along the way.
   510  Loop:
   511  	for {
   512  		var savedOffset int
   513  		if saveXML.IsValid() {
   514  			savedOffset = d.savedOffset()
   515  		}
   516  		tok, err := d.Token()
   517  		if err != nil {
   518  			return err
   519  		}
   520  		switch t := tok.(type) {
   521  		case StartElement:
   522  			consumed := false
   523  			if sv.IsValid() {
   524  				consumed, err = d.unmarshalPath(tinfo, sv, nil, &t)
   525  				if err != nil {
   526  					return err
   527  				}
   528  				if !consumed && saveAny.IsValid() {
   529  					consumed = true
   530  					if err := d.unmarshal(saveAny, &t); err != nil {
   531  						return err
   532  					}
   533  				}
   534  			}
   535  			if !consumed {
   536  				if err := d.Skip(); err != nil {
   537  					return err
   538  				}
   539  			}
   540  
   541  		case EndElement:
   542  			if saveXML.IsValid() {
   543  				saveXMLData = d.saved.Bytes()[saveXMLIndex:savedOffset]
   544  				if saveXMLIndex == 0 {
   545  					d.saved = nil
   546  				}
   547  			}
   548  			break Loop
   549  
   550  		case CharData:
   551  			if saveData.IsValid() {
   552  				data = append(data, t...)
   553  			}
   554  
   555  		case Comment:
   556  			if saveComment.IsValid() {
   557  				comment = append(comment, t...)
   558  			}
   559  		}
   560  	}
   561  
   562  	if saveData.IsValid() && saveData.CanInterface() && saveData.Type().Implements(textUnmarshalerType) {
   563  		if err := saveData.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
   564  			return err
   565  		}
   566  		saveData = reflect.Value{}
   567  	}
   568  
   569  	if saveData.IsValid() && saveData.CanAddr() {
   570  		pv := saveData.Addr()
   571  		if pv.CanInterface() && pv.Type().Implements(textUnmarshalerType) {
   572  			if err := pv.Interface().(encoding.TextUnmarshaler).UnmarshalText(data); err != nil {
   573  				return err
   574  			}
   575  			saveData = reflect.Value{}
   576  		}
   577  	}
   578  
   579  	if err := copyValue(saveData, data); err != nil {
   580  		return err
   581  	}
   582  
   583  	switch t := saveComment; t.Kind() {
   584  	case reflect.String:
   585  		t.SetString(string(comment))
   586  	case reflect.Slice:
   587  		t.Set(reflect.ValueOf(comment))
   588  	}
   589  
   590  	switch t := saveXML; t.Kind() {
   591  	case reflect.String:
   592  		t.SetString(string(saveXMLData))
   593  	case reflect.Slice:
   594  		if t.Type().Elem().Kind() == reflect.Uint8 {
   595  			t.Set(reflect.ValueOf(saveXMLData))
   596  		}
   597  	}
   598  
   599  	return nil
   600  }
   601  
   602  func copyValue(dst reflect.Value, src []byte) (err error) {
   603  	dst0 := dst
   604  
   605  	if dst.Kind() == reflect.Ptr {
   606  		if dst.IsNil() {
   607  			dst.Set(reflect.New(dst.Type().Elem()))
   608  		}
   609  		dst = dst.Elem()
   610  	}
   611  
   612  	// Save accumulated data.
   613  	switch dst.Kind() {
   614  	case reflect.Invalid:
   615  		// Probably a comment.
   616  	default:
   617  		return errors.New("cannot unmarshal into " + dst0.Type().String())
   618  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   619  		if len(src) == 0 {
   620  			dst.SetInt(0)
   621  			return nil
   622  		}
   623  		itmp, err := strconv.ParseInt(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
   624  		if err != nil {
   625  			return err
   626  		}
   627  		dst.SetInt(itmp)
   628  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   629  		if len(src) == 0 {
   630  			dst.SetUint(0)
   631  			return nil
   632  		}
   633  		utmp, err := strconv.ParseUint(strings.TrimSpace(string(src)), 10, dst.Type().Bits())
   634  		if err != nil {
   635  			return err
   636  		}
   637  		dst.SetUint(utmp)
   638  	case reflect.Float32, reflect.Float64:
   639  		if len(src) == 0 {
   640  			dst.SetFloat(0)
   641  			return nil
   642  		}
   643  		ftmp, err := strconv.ParseFloat(strings.TrimSpace(string(src)), dst.Type().Bits())
   644  		if err != nil {
   645  			return err
   646  		}
   647  		dst.SetFloat(ftmp)
   648  	case reflect.Bool:
   649  		if len(src) == 0 {
   650  			dst.SetBool(false)
   651  			return nil
   652  		}
   653  		value, err := strconv.ParseBool(strings.TrimSpace(string(src)))
   654  		if err != nil {
   655  			return err
   656  		}
   657  		dst.SetBool(value)
   658  	case reflect.String:
   659  		dst.SetString(string(src))
   660  	case reflect.Slice:
   661  		if len(src) == 0 {
   662  			// non-nil to flag presence
   663  			src = []byte{}
   664  		}
   665  		dst.SetBytes(src)
   666  	}
   667  	return nil
   668  }
   669  
   670  // unmarshalPath walks down an XML structure looking for wanted
   671  // paths, and calls unmarshal on them.
   672  // The consumed result tells whether XML elements have been consumed
   673  // from the Decoder until start's matching end element, or if it's
   674  // still untouched because start is uninteresting for sv's fields.
   675  func (d *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) {
   676  	recurse := false
   677  Loop:
   678  	for i := range tinfo.fields {
   679  		finfo := &tinfo.fields[i]
   680  		if finfo.flags&fElement == 0 || len(finfo.parents) < len(parents) || finfo.xmlns != "" && finfo.xmlns != start.Name.Space {
   681  			continue
   682  		}
   683  		for j := range parents {
   684  			if parents[j] != finfo.parents[j] {
   685  				continue Loop
   686  			}
   687  		}
   688  		if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local {
   689  			// It's a perfect match, unmarshal the field.
   690  			return true, d.unmarshal(finfo.value(sv), start)
   691  		}
   692  		if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local {
   693  			// It's a prefix for the field. Break and recurse
   694  			// since it's not ok for one field path to be itself
   695  			// the prefix for another field path.
   696  			recurse = true
   697  
   698  			// We can reuse the same slice as long as we
   699  			// don't try to append to it.
   700  			parents = finfo.parents[:len(parents)+1]
   701  			break
   702  		}
   703  	}
   704  	if !recurse {
   705  		// We have no business with this element.
   706  		return false, nil
   707  	}
   708  	// The element is not a perfect match for any field, but one
   709  	// or more fields have the path to this element as a parent
   710  	// prefix. Recurse and attempt to match these.
   711  	for {
   712  		var tok Token
   713  		tok, err = d.Token()
   714  		if err != nil {
   715  			return true, err
   716  		}
   717  		switch t := tok.(type) {
   718  		case StartElement:
   719  			consumed2, err := d.unmarshalPath(tinfo, sv, parents, &t)
   720  			if err != nil {
   721  				return true, err
   722  			}
   723  			if !consumed2 {
   724  				if err := d.Skip(); err != nil {
   725  					return true, err
   726  				}
   727  			}
   728  		case EndElement:
   729  			return true, nil
   730  		}
   731  	}
   732  }
   733  
   734  // Skip reads tokens until it has consumed the end element
   735  // matching the most recent start element already consumed.
   736  // It recurs if it encounters a start element, so it can be used to
   737  // skip nested structures.
   738  // It returns nil if it finds an end element matching the start
   739  // element; otherwise it returns an error describing the problem.
   740  func (d *Decoder) Skip() error {
   741  	for {
   742  		tok, err := d.Token()
   743  		if err != nil {
   744  			return err
   745  		}
   746  		switch tok.(type) {
   747  		case StartElement:
   748  			if err := d.Skip(); err != nil {
   749  				return err
   750  			}
   751  		case EndElement:
   752  			return nil
   753  		}
   754  	}
   755  }
   756  

View as plain text