Source file src/pkg/encoding/xml/typeinfo.go

     1	// Copyright 2011 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		"fmt"
     9		"reflect"
    10		"strings"
    11		"sync"
    12	)
    13	
    14	// typeInfo holds details for the xml representation of a type.
    15	type typeInfo struct {
    16		xmlname *fieldInfo
    17		fields  []fieldInfo
    18	}
    19	
    20	// fieldInfo holds details for the xml representation of a single field.
    21	type fieldInfo struct {
    22		idx     []int
    23		name    string
    24		xmlns   string
    25		flags   fieldFlags
    26		parents []string
    27	}
    28	
    29	type fieldFlags int
    30	
    31	const (
    32		fElement fieldFlags = 1 << iota
    33		fAttr
    34		fCharData
    35		fInnerXml
    36		fComment
    37		fAny
    38	
    39		fOmitEmpty
    40	
    41		fMode = fElement | fAttr | fCharData | fInnerXml | fComment | fAny
    42	)
    43	
    44	var tinfoMap = make(map[reflect.Type]*typeInfo)
    45	var tinfoLock sync.RWMutex
    46	
    47	var nameType = reflect.TypeOf(Name{})
    48	
    49	// getTypeInfo returns the typeInfo structure with details necessary
    50	// for marshalling and unmarshalling typ.
    51	func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
    52		tinfoLock.RLock()
    53		tinfo, ok := tinfoMap[typ]
    54		tinfoLock.RUnlock()
    55		if ok {
    56			return tinfo, nil
    57		}
    58		tinfo = &typeInfo{}
    59		if typ.Kind() == reflect.Struct && typ != nameType {
    60			n := typ.NumField()
    61			for i := 0; i < n; i++ {
    62				f := typ.Field(i)
    63				if f.PkgPath != "" || f.Tag.Get("xml") == "-" {
    64					continue // Private field
    65				}
    66	
    67				// For embedded structs, embed its fields.
    68				if f.Anonymous {
    69					if f.Type.Kind() != reflect.Struct {
    70						continue
    71					}
    72					inner, err := getTypeInfo(f.Type)
    73					if err != nil {
    74						return nil, err
    75					}
    76					for _, finfo := range inner.fields {
    77						finfo.idx = append([]int{i}, finfo.idx...)
    78						if err := addFieldInfo(typ, tinfo, &finfo); err != nil {
    79							return nil, err
    80						}
    81					}
    82					continue
    83				}
    84	
    85				finfo, err := structFieldInfo(typ, &f)
    86				if err != nil {
    87					return nil, err
    88				}
    89	
    90				if f.Name == "XMLName" {
    91					tinfo.xmlname = finfo
    92					continue
    93				}
    94	
    95				// Add the field if it doesn't conflict with other fields.
    96				if err := addFieldInfo(typ, tinfo, finfo); err != nil {
    97					return nil, err
    98				}
    99			}
   100		}
   101		tinfoLock.Lock()
   102		tinfoMap[typ] = tinfo
   103		tinfoLock.Unlock()
   104		return tinfo, nil
   105	}
   106	
   107	// structFieldInfo builds and returns a fieldInfo for f.
   108	func structFieldInfo(typ reflect.Type, f *reflect.StructField) (*fieldInfo, error) {
   109		finfo := &fieldInfo{idx: f.Index}
   110	
   111		// Split the tag from the xml namespace if necessary.
   112		tag := f.Tag.Get("xml")
   113		if i := strings.Index(tag, " "); i >= 0 {
   114			finfo.xmlns, tag = tag[:i], tag[i+1:]
   115		}
   116	
   117		// Parse flags.
   118		tokens := strings.Split(tag, ",")
   119		if len(tokens) == 1 {
   120			finfo.flags = fElement
   121		} else {
   122			tag = tokens[0]
   123			for _, flag := range tokens[1:] {
   124				switch flag {
   125				case "attr":
   126					finfo.flags |= fAttr
   127				case "chardata":
   128					finfo.flags |= fCharData
   129				case "innerxml":
   130					finfo.flags |= fInnerXml
   131				case "comment":
   132					finfo.flags |= fComment
   133				case "any":
   134					finfo.flags |= fAny
   135				case "omitempty":
   136					finfo.flags |= fOmitEmpty
   137				}
   138			}
   139	
   140			// Validate the flags used.
   141			valid := true
   142			switch mode := finfo.flags & fMode; mode {
   143			case 0:
   144				finfo.flags |= fElement
   145			case fAttr, fCharData, fInnerXml, fComment, fAny:
   146				if f.Name == "XMLName" || tag != "" && mode != fAttr {
   147					valid = false
   148				}
   149			default:
   150				// This will also catch multiple modes in a single field.
   151				valid = false
   152			}
   153			if finfo.flags&fOmitEmpty != 0 && finfo.flags&(fElement|fAttr) == 0 {
   154				valid = false
   155			}
   156			if !valid {
   157				return nil, fmt.Errorf("xml: invalid tag in field %s of type %s: %q",
   158					f.Name, typ, f.Tag.Get("xml"))
   159			}
   160		}
   161	
   162		// Use of xmlns without a name is not allowed.
   163		if finfo.xmlns != "" && tag == "" {
   164			return nil, fmt.Errorf("xml: namespace without name in field %s of type %s: %q",
   165				f.Name, typ, f.Tag.Get("xml"))
   166		}
   167	
   168		if f.Name == "XMLName" {
   169			// The XMLName field records the XML element name. Don't
   170			// process it as usual because its name should default to
   171			// empty rather than to the field name.
   172			finfo.name = tag
   173			return finfo, nil
   174		}
   175	
   176		if tag == "" {
   177			// If the name part of the tag is completely empty, get
   178			// default from XMLName of underlying struct if feasible,
   179			// or field name otherwise.
   180			if xmlname := lookupXMLName(f.Type); xmlname != nil {
   181				finfo.xmlns, finfo.name = xmlname.xmlns, xmlname.name
   182			} else {
   183				finfo.name = f.Name
   184			}
   185			return finfo, nil
   186		}
   187	
   188		// Prepare field name and parents.
   189		tokens = strings.Split(tag, ">")
   190		if tokens[0] == "" {
   191			tokens[0] = f.Name
   192		}
   193		if tokens[len(tokens)-1] == "" {
   194			return nil, fmt.Errorf("xml: trailing '>' in field %s of type %s", f.Name, typ)
   195		}
   196		finfo.name = tokens[len(tokens)-1]
   197		if len(tokens) > 1 {
   198			finfo.parents = tokens[:len(tokens)-1]
   199		}
   200	
   201		// If the field type has an XMLName field, the names must match
   202		// so that the behavior of both marshalling and unmarshalling
   203		// is straightforward and unambiguous.
   204		if finfo.flags&fElement != 0 {
   205			ftyp := f.Type
   206			xmlname := lookupXMLName(ftyp)
   207			if xmlname != nil && xmlname.name != finfo.name {
   208				return nil, fmt.Errorf("xml: name %q in tag of %s.%s conflicts with name %q in %s.XMLName",
   209					finfo.name, typ, f.Name, xmlname.name, ftyp)
   210			}
   211		}
   212		return finfo, nil
   213	}
   214	
   215	// lookupXMLName returns the fieldInfo for typ's XMLName field
   216	// in case it exists and has a valid xml field tag, otherwise
   217	// it returns nil.
   218	func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
   219		for typ.Kind() == reflect.Ptr {
   220			typ = typ.Elem()
   221		}
   222		if typ.Kind() != reflect.Struct {
   223			return nil
   224		}
   225		for i, n := 0, typ.NumField(); i < n; i++ {
   226			f := typ.Field(i)
   227			if f.Name != "XMLName" {
   228				continue
   229			}
   230			finfo, err := structFieldInfo(typ, &f)
   231			if finfo.name != "" && err == nil {
   232				return finfo
   233			}
   234			// Also consider errors as a non-existent field tag
   235			// and let getTypeInfo itself report the error.
   236			break
   237		}
   238		return nil
   239	}
   240	
   241	func min(a, b int) int {
   242		if a <= b {
   243			return a
   244		}
   245		return b
   246	}
   247	
   248	// addFieldInfo adds finfo to tinfo.fields if there are no
   249	// conflicts, or if conflicts arise from previous fields that were
   250	// obtained from deeper embedded structures than finfo. In the latter
   251	// case, the conflicting entries are dropped.
   252	// A conflict occurs when the path (parent + name) to a field is
   253	// itself a prefix of another path, or when two paths match exactly.
   254	// It is okay for field paths to share a common, shorter prefix.
   255	func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error {
   256		var conflicts []int
   257	Loop:
   258		// First, figure all conflicts. Most working code will have none.
   259		for i := range tinfo.fields {
   260			oldf := &tinfo.fields[i]
   261			if oldf.flags&fMode != newf.flags&fMode {
   262				continue
   263			}
   264			minl := min(len(newf.parents), len(oldf.parents))
   265			for p := 0; p < minl; p++ {
   266				if oldf.parents[p] != newf.parents[p] {
   267					continue Loop
   268				}
   269			}
   270			if len(oldf.parents) > len(newf.parents) {
   271				if oldf.parents[len(newf.parents)] == newf.name {
   272					conflicts = append(conflicts, i)
   273				}
   274			} else if len(oldf.parents) < len(newf.parents) {
   275				if newf.parents[len(oldf.parents)] == oldf.name {
   276					conflicts = append(conflicts, i)
   277				}
   278			} else {
   279				if newf.name == oldf.name {
   280					conflicts = append(conflicts, i)
   281				}
   282			}
   283		}
   284		// Without conflicts, add the new field and return.
   285		if conflicts == nil {
   286			tinfo.fields = append(tinfo.fields, *newf)
   287			return nil
   288		}
   289	
   290		// If any conflict is shallower, ignore the new field.
   291		// This matches the Go field resolution on embedding.
   292		for _, i := range conflicts {
   293			if len(tinfo.fields[i].idx) < len(newf.idx) {
   294				return nil
   295			}
   296		}
   297	
   298		// Otherwise, if any of them is at the same depth level, it's an error.
   299		for _, i := range conflicts {
   300			oldf := &tinfo.fields[i]
   301			if len(oldf.idx) == len(newf.idx) {
   302				f1 := typ.FieldByIndex(oldf.idx)
   303				f2 := typ.FieldByIndex(newf.idx)
   304				return &TagPathError{typ, f1.Name, f1.Tag.Get("xml"), f2.Name, f2.Tag.Get("xml")}
   305			}
   306		}
   307	
   308		// Otherwise, the new field is shallower, and thus takes precedence,
   309		// so drop the conflicting fields from tinfo and append the new one.
   310		for c := len(conflicts) - 1; c >= 0; c-- {
   311			i := conflicts[c]
   312			copy(tinfo.fields[i:], tinfo.fields[i+1:])
   313			tinfo.fields = tinfo.fields[:len(tinfo.fields)-1]
   314		}
   315		tinfo.fields = append(tinfo.fields, *newf)
   316		return nil
   317	}
   318	
   319	// A TagPathError represents an error in the unmarshalling process
   320	// caused by the use of field tags with conflicting paths.
   321	type TagPathError struct {
   322		Struct       reflect.Type
   323		Field1, Tag1 string
   324		Field2, Tag2 string
   325	}
   326	
   327	func (e *TagPathError) Error() string {
   328		return fmt.Sprintf("%s field %q with tag %q conflicts with field %q with tag %q", e.Struct, e.Field1, e.Tag1, e.Field2, e.Tag2)
   329	}