mirror of
https://github.com/restic/restic.git
synced 2024-08-20 03:13:22 +02:00
372 lines
9.5 KiB
Go
372 lines
9.5 KiB
Go
// Copyright 2011 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
package xml
|
|
|
|
import (
|
|
"fmt"
|
|
"reflect"
|
|
"strings"
|
|
"sync"
|
|
)
|
|
|
|
// typeInfo holds details for the xml representation of a type.
|
|
type typeInfo struct {
|
|
xmlname *fieldInfo
|
|
fields []fieldInfo
|
|
}
|
|
|
|
// fieldInfo holds details for the xml representation of a single field.
|
|
type fieldInfo struct {
|
|
idx []int
|
|
name string
|
|
xmlns string
|
|
flags fieldFlags
|
|
parents []string
|
|
}
|
|
|
|
type fieldFlags int
|
|
|
|
const (
|
|
fElement fieldFlags = 1 << iota
|
|
fAttr
|
|
fCharData
|
|
fInnerXml
|
|
fComment
|
|
fAny
|
|
|
|
fOmitEmpty
|
|
|
|
fMode = fElement | fAttr | fCharData | fInnerXml | fComment | fAny
|
|
)
|
|
|
|
var tinfoMap = make(map[reflect.Type]*typeInfo)
|
|
var tinfoLock sync.RWMutex
|
|
|
|
var nameType = reflect.TypeOf(Name{})
|
|
|
|
// getTypeInfo returns the typeInfo structure with details necessary
|
|
// for marshalling and unmarshalling typ.
|
|
func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
|
|
tinfoLock.RLock()
|
|
tinfo, ok := tinfoMap[typ]
|
|
tinfoLock.RUnlock()
|
|
if ok {
|
|
return tinfo, nil
|
|
}
|
|
tinfo = &typeInfo{}
|
|
if typ.Kind() == reflect.Struct && typ != nameType {
|
|
n := typ.NumField()
|
|
for i := 0; i < n; i++ {
|
|
f := typ.Field(i)
|
|
if f.PkgPath != "" || f.Tag.Get("xml") == "-" {
|
|
continue // Private field
|
|
}
|
|
|
|
// For embedded structs, embed its fields.
|
|
if f.Anonymous {
|
|
t := f.Type
|
|
if t.Kind() == reflect.Ptr {
|
|
t = t.Elem()
|
|
}
|
|
if t.Kind() == reflect.Struct {
|
|
inner, err := getTypeInfo(t)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
if tinfo.xmlname == nil {
|
|
tinfo.xmlname = inner.xmlname
|
|
}
|
|
for _, finfo := range inner.fields {
|
|
finfo.idx = append([]int{i}, finfo.idx...)
|
|
if err := addFieldInfo(typ, tinfo, &finfo); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
continue
|
|
}
|
|
}
|
|
|
|
finfo, err := structFieldInfo(typ, &f)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if f.Name == "XMLName" {
|
|
tinfo.xmlname = finfo
|
|
continue
|
|
}
|
|
|
|
// Add the field if it doesn't conflict with other fields.
|
|
if err := addFieldInfo(typ, tinfo, finfo); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
}
|
|
tinfoLock.Lock()
|
|
tinfoMap[typ] = tinfo
|
|
tinfoLock.Unlock()
|
|
return tinfo, nil
|
|
}
|
|
|
|
// structFieldInfo builds and returns a fieldInfo for f.
|
|
func structFieldInfo(typ reflect.Type, f *reflect.StructField) (*fieldInfo, error) {
|
|
finfo := &fieldInfo{idx: f.Index}
|
|
|
|
// Split the tag from the xml namespace if necessary.
|
|
tag := f.Tag.Get("xml")
|
|
if i := strings.Index(tag, " "); i >= 0 {
|
|
finfo.xmlns, tag = tag[:i], tag[i+1:]
|
|
}
|
|
|
|
// Parse flags.
|
|
tokens := strings.Split(tag, ",")
|
|
if len(tokens) == 1 {
|
|
finfo.flags = fElement
|
|
} else {
|
|
tag = tokens[0]
|
|
for _, flag := range tokens[1:] {
|
|
switch flag {
|
|
case "attr":
|
|
finfo.flags |= fAttr
|
|
case "chardata":
|
|
finfo.flags |= fCharData
|
|
case "innerxml":
|
|
finfo.flags |= fInnerXml
|
|
case "comment":
|
|
finfo.flags |= fComment
|
|
case "any":
|
|
finfo.flags |= fAny
|
|
case "omitempty":
|
|
finfo.flags |= fOmitEmpty
|
|
}
|
|
}
|
|
|
|
// Validate the flags used.
|
|
valid := true
|
|
switch mode := finfo.flags & fMode; mode {
|
|
case 0:
|
|
finfo.flags |= fElement
|
|
case fAttr, fCharData, fInnerXml, fComment, fAny:
|
|
if f.Name == "XMLName" || tag != "" && mode != fAttr {
|
|
valid = false
|
|
}
|
|
default:
|
|
// This will also catch multiple modes in a single field.
|
|
valid = false
|
|
}
|
|
if finfo.flags&fMode == fAny {
|
|
finfo.flags |= fElement
|
|
}
|
|
if finfo.flags&fOmitEmpty != 0 && finfo.flags&(fElement|fAttr) == 0 {
|
|
valid = false
|
|
}
|
|
if !valid {
|
|
return nil, fmt.Errorf("xml: invalid tag in field %s of type %s: %q",
|
|
f.Name, typ, f.Tag.Get("xml"))
|
|
}
|
|
}
|
|
|
|
// Use of xmlns without a name is not allowed.
|
|
if finfo.xmlns != "" && tag == "" {
|
|
return nil, fmt.Errorf("xml: namespace without name in field %s of type %s: %q",
|
|
f.Name, typ, f.Tag.Get("xml"))
|
|
}
|
|
|
|
if f.Name == "XMLName" {
|
|
// The XMLName field records the XML element name. Don't
|
|
// process it as usual because its name should default to
|
|
// empty rather than to the field name.
|
|
finfo.name = tag
|
|
return finfo, nil
|
|
}
|
|
|
|
if tag == "" {
|
|
// If the name part of the tag is completely empty, get
|
|
// default from XMLName of underlying struct if feasible,
|
|
// or field name otherwise.
|
|
if xmlname := lookupXMLName(f.Type); xmlname != nil {
|
|
finfo.xmlns, finfo.name = xmlname.xmlns, xmlname.name
|
|
} else {
|
|
finfo.name = f.Name
|
|
}
|
|
return finfo, nil
|
|
}
|
|
|
|
if finfo.xmlns == "" && finfo.flags&fAttr == 0 {
|
|
// If it's an element no namespace specified, get the default
|
|
// from the XMLName of enclosing struct if possible.
|
|
if xmlname := lookupXMLName(typ); xmlname != nil {
|
|
finfo.xmlns = xmlname.xmlns
|
|
}
|
|
}
|
|
|
|
// Prepare field name and parents.
|
|
parents := strings.Split(tag, ">")
|
|
if parents[0] == "" {
|
|
parents[0] = f.Name
|
|
}
|
|
if parents[len(parents)-1] == "" {
|
|
return nil, fmt.Errorf("xml: trailing '>' in field %s of type %s", f.Name, typ)
|
|
}
|
|
finfo.name = parents[len(parents)-1]
|
|
if len(parents) > 1 {
|
|
if (finfo.flags & fElement) == 0 {
|
|
return nil, fmt.Errorf("xml: %s chain not valid with %s flag", tag, strings.Join(tokens[1:], ","))
|
|
}
|
|
finfo.parents = parents[:len(parents)-1]
|
|
}
|
|
|
|
// If the field type has an XMLName field, the names must match
|
|
// so that the behavior of both marshalling and unmarshalling
|
|
// is straightforward and unambiguous.
|
|
if finfo.flags&fElement != 0 {
|
|
ftyp := f.Type
|
|
xmlname := lookupXMLName(ftyp)
|
|
if xmlname != nil && xmlname.name != finfo.name {
|
|
return nil, fmt.Errorf("xml: name %q in tag of %s.%s conflicts with name %q in %s.XMLName",
|
|
finfo.name, typ, f.Name, xmlname.name, ftyp)
|
|
}
|
|
}
|
|
return finfo, nil
|
|
}
|
|
|
|
// lookupXMLName returns the fieldInfo for typ's XMLName field
|
|
// in case it exists and has a valid xml field tag, otherwise
|
|
// it returns nil.
|
|
func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
|
|
for typ.Kind() == reflect.Ptr {
|
|
typ = typ.Elem()
|
|
}
|
|
if typ.Kind() != reflect.Struct {
|
|
return nil
|
|
}
|
|
for i, n := 0, typ.NumField(); i < n; i++ {
|
|
f := typ.Field(i)
|
|
if f.Name != "XMLName" {
|
|
continue
|
|
}
|
|
finfo, err := structFieldInfo(typ, &f)
|
|
if finfo.name != "" && err == nil {
|
|
return finfo
|
|
}
|
|
// Also consider errors as a non-existent field tag
|
|
// and let getTypeInfo itself report the error.
|
|
break
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func min(a, b int) int {
|
|
if a <= b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
// addFieldInfo adds finfo to tinfo.fields if there are no
|
|
// conflicts, or if conflicts arise from previous fields that were
|
|
// obtained from deeper embedded structures than finfo. In the latter
|
|
// case, the conflicting entries are dropped.
|
|
// A conflict occurs when the path (parent + name) to a field is
|
|
// itself a prefix of another path, or when two paths match exactly.
|
|
// It is okay for field paths to share a common, shorter prefix.
|
|
func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error {
|
|
var conflicts []int
|
|
Loop:
|
|
// First, figure all conflicts. Most working code will have none.
|
|
for i := range tinfo.fields {
|
|
oldf := &tinfo.fields[i]
|
|
if oldf.flags&fMode != newf.flags&fMode {
|
|
continue
|
|
}
|
|
if oldf.xmlns != "" && newf.xmlns != "" && oldf.xmlns != newf.xmlns {
|
|
continue
|
|
}
|
|
minl := min(len(newf.parents), len(oldf.parents))
|
|
for p := 0; p < minl; p++ {
|
|
if oldf.parents[p] != newf.parents[p] {
|
|
continue Loop
|
|
}
|
|
}
|
|
if len(oldf.parents) > len(newf.parents) {
|
|
if oldf.parents[len(newf.parents)] == newf.name {
|
|
conflicts = append(conflicts, i)
|
|
}
|
|
} else if len(oldf.parents) < len(newf.parents) {
|
|
if newf.parents[len(oldf.parents)] == oldf.name {
|
|
conflicts = append(conflicts, i)
|
|
}
|
|
} else {
|
|
if newf.name == oldf.name {
|
|
conflicts = append(conflicts, i)
|
|
}
|
|
}
|
|
}
|
|
// Without conflicts, add the new field and return.
|
|
if conflicts == nil {
|
|
tinfo.fields = append(tinfo.fields, *newf)
|
|
return nil
|
|
}
|
|
|
|
// If any conflict is shallower, ignore the new field.
|
|
// This matches the Go field resolution on embedding.
|
|
for _, i := range conflicts {
|
|
if len(tinfo.fields[i].idx) < len(newf.idx) {
|
|
return nil
|
|
}
|
|
}
|
|
|
|
// Otherwise, if any of them is at the same depth level, it's an error.
|
|
for _, i := range conflicts {
|
|
oldf := &tinfo.fields[i]
|
|
if len(oldf.idx) == len(newf.idx) {
|
|
f1 := typ.FieldByIndex(oldf.idx)
|
|
f2 := typ.FieldByIndex(newf.idx)
|
|
return &TagPathError{typ, f1.Name, f1.Tag.Get("xml"), f2.Name, f2.Tag.Get("xml")}
|
|
}
|
|
}
|
|
|
|
// Otherwise, the new field is shallower, and thus takes precedence,
|
|
// so drop the conflicting fields from tinfo and append the new one.
|
|
for c := len(conflicts) - 1; c >= 0; c-- {
|
|
i := conflicts[c]
|
|
copy(tinfo.fields[i:], tinfo.fields[i+1:])
|
|
tinfo.fields = tinfo.fields[:len(tinfo.fields)-1]
|
|
}
|
|
tinfo.fields = append(tinfo.fields, *newf)
|
|
return nil
|
|
}
|
|
|
|
// A TagPathError represents an error in the unmarshalling process
|
|
// caused by the use of field tags with conflicting paths.
|
|
type TagPathError struct {
|
|
Struct reflect.Type
|
|
Field1, Tag1 string
|
|
Field2, Tag2 string
|
|
}
|
|
|
|
func (e *TagPathError) Error() string {
|
|
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)
|
|
}
|
|
|
|
// value returns v's field value corresponding to finfo.
|
|
// It's equivalent to v.FieldByIndex(finfo.idx), but initializes
|
|
// and dereferences pointers as necessary.
|
|
func (finfo *fieldInfo) value(v reflect.Value) reflect.Value {
|
|
for i, x := range finfo.idx {
|
|
if i > 0 {
|
|
t := v.Type()
|
|
if t.Kind() == reflect.Ptr && t.Elem().Kind() == reflect.Struct {
|
|
if v.IsNil() {
|
|
v.Set(reflect.New(v.Type().Elem()))
|
|
}
|
|
v = v.Elem()
|
|
}
|
|
}
|
|
v = v.Field(x)
|
|
}
|
|
return v
|
|
}
|