yaml.go

Documentation: gopkg.in/yaml.v3

     1  //
     2  // Copyright (c) 2011-2019 Canonical Ltd
     3  //
     4  // Licensed under the Apache License, Version 2.0 (the "License");
     5  // you may not use this file except in compliance with the License.
     6  // You may obtain a copy of the License at
     7  //
     8  //     http://www.apache.org/licenses/LICENSE-2.0
     9  //
    10  // Unless required by applicable law or agreed to in writing, software
    11  // distributed under the License is distributed on an "AS IS" BASIS,
    12  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  // See the License for the specific language governing permissions and
    14  // limitations under the License.
    15  
    16  // Package yaml implements YAML support for the Go language.
    17  //
    18  // Source code and other details for the project are available at GitHub:
    19  //
    20  //   https://github.com/go-yaml/yaml
    21  //
    22  package yaml
    23  
    24  import (
    25  	"errors"
    26  	"fmt"
    27  	"io"
    28  	"reflect"
    29  	"strings"
    30  	"sync"
    31  	"unicode/utf8"
    32  )
    33  
    34  // The Unmarshaler interface may be implemented by types to customize their
    35  // behavior when being unmarshaled from a YAML document.
    36  type Unmarshaler interface {
    37  	UnmarshalYAML(value *Node) error
    38  }
    39  
    40  type obsoleteUnmarshaler interface {
    41  	UnmarshalYAML(unmarshal func(interface{}) error) error
    42  }
    43  
    44  // The Marshaler interface may be implemented by types to customize their
    45  // behavior when being marshaled into a YAML document. The returned value
    46  // is marshaled in place of the original value implementing Marshaler.
    47  //
    48  // If an error is returned by MarshalYAML, the marshaling procedure stops
    49  // and returns with the provided error.
    50  type Marshaler interface {
    51  	MarshalYAML() (interface{}, error)
    52  }
    53  
    54  // Unmarshal decodes the first document found within the in byte slice
    55  // and assigns decoded values into the out value.
    56  //
    57  // Maps and pointers (to a struct, string, int, etc) are accepted as out
    58  // values. If an internal pointer within a struct is not initialized,
    59  // the yaml package will initialize it if necessary for unmarshalling
    60  // the provided data. The out parameter must not be nil.
    61  //
    62  // The type of the decoded values should be compatible with the respective
    63  // values in out. If one or more values cannot be decoded due to a type
    64  // mismatches, decoding continues partially until the end of the YAML
    65  // content, and a *yaml.TypeError is returned with details for all
    66  // missed values.
    67  //
    68  // Struct fields are only unmarshalled if they are exported (have an
    69  // upper case first letter), and are unmarshalled using the field name
    70  // lowercased as the default key. Custom keys may be defined via the
    71  // "yaml" name in the field tag: the content preceding the first comma
    72  // is used as the key, and the following comma-separated options are
    73  // used to tweak the marshalling process (see Marshal).
    74  // Conflicting names result in a runtime error.
    75  //
    76  // For example:
    77  //
    78  //     type T struct {
    79  //         F int `yaml:"a,omitempty"`
    80  //         B int
    81  //     }
    82  //     var t T
    83  //     yaml.Unmarshal([]byte("a: 1\nb: 2"), &t)
    84  //
    85  // See the documentation of Marshal for the format of tags and a list of
    86  // supported tag options.
    87  //
    88  func Unmarshal(in []byte, out interface{}) (err error) {
    89  	return unmarshal(in, out, false)
    90  }
    91  
    92  // A Decoder reads and decodes YAML values from an input stream.
    93  type Decoder struct {
    94  	parser      *parser
    95  	knownFields bool
    96  }
    97  
    98  // NewDecoder returns a new decoder that reads from r.
    99  //
   100  // The decoder introduces its own buffering and may read
   101  // data from r beyond the YAML values requested.
   102  func NewDecoder(r io.Reader) *Decoder {
   103  	return &Decoder{
   104  		parser: newParserFromReader(r),
   105  	}
   106  }
   107  
   108  // KnownFields ensures that the keys in decoded mappings to
   109  // exist as fields in the struct being decoded into.
   110  func (dec *Decoder) KnownFields(enable bool) {
   111  	dec.knownFields = enable
   112  }
   113  
   114  // Decode reads the next YAML-encoded value from its input
   115  // and stores it in the value pointed to by v.
   116  //
   117  // See the documentation for Unmarshal for details about the
   118  // conversion of YAML into a Go value.
   119  func (dec *Decoder) Decode(v interface{}) (err error) {
   120  	d := newDecoder()
   121  	d.knownFields = dec.knownFields
   122  	defer handleErr(&err)
   123  	node := dec.parser.parse()
   124  	if node == nil {
   125  		return io.EOF
   126  	}
   127  	out := reflect.ValueOf(v)
   128  	if out.Kind() == reflect.Ptr && !out.IsNil() {
   129  		out = out.Elem()
   130  	}
   131  	d.unmarshal(node, out)
   132  	if len(d.terrors) > 0 {
   133  		return &TypeError{d.terrors}
   134  	}
   135  	return nil
   136  }
   137  
   138  // Decode decodes the node and stores its data into the value pointed to by v.
   139  //
   140  // See the documentation for Unmarshal for details about the
   141  // conversion of YAML into a Go value.
   142  func (n *Node) Decode(v interface{}) (err error) {
   143  	d := newDecoder()
   144  	defer handleErr(&err)
   145  	out := reflect.ValueOf(v)
   146  	if out.Kind() == reflect.Ptr && !out.IsNil() {
   147  		out = out.Elem()
   148  	}
   149  	d.unmarshal(n, out)
   150  	if len(d.terrors) > 0 {
   151  		return &TypeError{d.terrors}
   152  	}
   153  	return nil
   154  }
   155  
   156  func unmarshal(in []byte, out interface{}, strict bool) (err error) {
   157  	defer handleErr(&err)
   158  	d := newDecoder()
   159  	p := newParser(in)
   160  	defer p.destroy()
   161  	node := p.parse()
   162  	if node != nil {
   163  		v := reflect.ValueOf(out)
   164  		if v.Kind() == reflect.Ptr && !v.IsNil() {
   165  			v = v.Elem()
   166  		}
   167  		d.unmarshal(node, v)
   168  	}
   169  	if len(d.terrors) > 0 {
   170  		return &TypeError{d.terrors}
   171  	}
   172  	return nil
   173  }
   174  
   175  // Marshal serializes the value provided into a YAML document. The structure
   176  // of the generated document will reflect the structure of the value itself.
   177  // Maps and pointers (to struct, string, int, etc) are accepted as the in value.
   178  //
   179  // Struct fields are only marshalled if they are exported (have an upper case
   180  // first letter), and are marshalled using the field name lowercased as the
   181  // default key. Custom keys may be defined via the "yaml" name in the field
   182  // tag: the content preceding the first comma is used as the key, and the
   183  // following comma-separated options are used to tweak the marshalling process.
   184  // Conflicting names result in a runtime error.
   185  //
   186  // The field tag format accepted is:
   187  //
   188  //     `(...) yaml:"[<key>][,<flag1>[,<flag2>]]" (...)`
   189  //
   190  // The following flags are currently supported:
   191  //
   192  //     omitempty    Only include the field if it's not set to the zero
   193  //                  value for the type or to empty slices or maps.
   194  //                  Zero valued structs will be omitted if all their public
   195  //                  fields are zero, unless they implement an IsZero
   196  //                  method (see the IsZeroer interface type), in which
   197  //                  case the field will be excluded if IsZero returns true.
   198  //
   199  //     flow         Marshal using a flow style (useful for structs,
   200  //                  sequences and maps).
   201  //
   202  //     inline       Inline the field, which must be a struct or a map,
   203  //                  causing all of its fields or keys to be processed as if
   204  //                  they were part of the outer struct. For maps, keys must
   205  //                  not conflict with the yaml keys of other struct fields.
   206  //
   207  // In addition, if the key is "-", the field is ignored.
   208  //
   209  // For example:
   210  //
   211  //     type T struct {
   212  //         F int `yaml:"a,omitempty"`
   213  //         B int
   214  //     }
   215  //     yaml.Marshal(&T{B: 2}) // Returns "b: 2\n"
   216  //     yaml.Marshal(&T{F: 1}} // Returns "a: 1\nb: 0\n"
   217  //
   218  func Marshal(in interface{}) (out []byte, err error) {
   219  	defer handleErr(&err)
   220  	e := newEncoder()
   221  	defer e.destroy()
   222  	e.marshalDoc("", reflect.ValueOf(in))
   223  	e.finish()
   224  	out = e.out
   225  	return
   226  }
   227  
   228  // An Encoder writes YAML values to an output stream.
   229  type Encoder struct {
   230  	encoder *encoder
   231  }
   232  
   233  // NewEncoder returns a new encoder that writes to w.
   234  // The Encoder should be closed after use to flush all data
   235  // to w.
   236  func NewEncoder(w io.Writer) *Encoder {
   237  	return &Encoder{
   238  		encoder: newEncoderWithWriter(w),
   239  	}
   240  }
   241  
   242  // Encode writes the YAML encoding of v to the stream.
   243  // If multiple items are encoded to the stream, the
   244  // second and subsequent document will be preceded
   245  // with a "---" document separator, but the first will not.
   246  //
   247  // See the documentation for Marshal for details about the conversion of Go
   248  // values to YAML.
   249  func (e *Encoder) Encode(v interface{}) (err error) {
   250  	defer handleErr(&err)
   251  	e.encoder.marshalDoc("", reflect.ValueOf(v))
   252  	return nil
   253  }
   254  
   255  // Encode encodes value v and stores its representation in n.
   256  //
   257  // See the documentation for Marshal for details about the
   258  // conversion of Go values into YAML.
   259  func (n *Node) Encode(v interface{}) (err error) {
   260  	defer handleErr(&err)
   261  	e := newEncoder()
   262  	defer e.destroy()
   263  	e.marshalDoc("", reflect.ValueOf(v))
   264  	e.finish()
   265  	p := newParser(e.out)
   266  	p.textless = true
   267  	defer p.destroy()
   268  	doc := p.parse()
   269  	*n = *doc.Content[0]
   270  	return nil
   271  }
   272  
   273  // SetIndent changes the used indentation used when encoding.
   274  func (e *Encoder) SetIndent(spaces int) {
   275  	if spaces < 0 {
   276  		panic("yaml: cannot indent to a negative number of spaces")
   277  	}
   278  	e.encoder.indent = spaces
   279  }
   280  
   281  // Close closes the encoder by writing any remaining data.
   282  // It does not write a stream terminating string "...".
   283  func (e *Encoder) Close() (err error) {
   284  	defer handleErr(&err)
   285  	e.encoder.finish()
   286  	return nil
   287  }
   288  
   289  func handleErr(err *error) {
   290  	if v := recover(); v != nil {
   291  		if e, ok := v.(yamlError); ok {
   292  			*err = e.err
   293  		} else {
   294  			panic(v)
   295  		}
   296  	}
   297  }
   298  
   299  type yamlError struct {
   300  	err error
   301  }
   302  
   303  func fail(err error) {
   304  	panic(yamlError{err})
   305  }
   306  
   307  func failf(format string, args ...interface{}) {
   308  	panic(yamlError{fmt.Errorf("yaml: "+format, args...)})
   309  }
   310  
   311  // A TypeError is returned by Unmarshal when one or more fields in
   312  // the YAML document cannot be properly decoded into the requested
   313  // types. When this error is returned, the value is still
   314  // unmarshaled partially.
   315  type TypeError struct {
   316  	Errors []string
   317  }
   318  
   319  func (e *TypeError) Error() string {
   320  	return fmt.Sprintf("yaml: unmarshal errors:\n  %s", strings.Join(e.Errors, "\n  "))
   321  }
   322  
   323  type Kind uint32
   324  
   325  const (
   326  	DocumentNode Kind = 1 << iota
   327  	SequenceNode
   328  	MappingNode
   329  	ScalarNode
   330  	AliasNode
   331  )
   332  
   333  type Style uint32
   334  
   335  const (
   336  	TaggedStyle Style = 1 << iota
   337  	DoubleQuotedStyle
   338  	SingleQuotedStyle
   339  	LiteralStyle
   340  	FoldedStyle
   341  	FlowStyle
   342  )
   343  
   344  // Node represents an element in the YAML document hierarchy. While documents
   345  // are typically encoded and decoded into higher level types, such as structs
   346  // and maps, Node is an intermediate representation that allows detailed
   347  // control over the content being decoded or encoded.
   348  //
   349  // It's worth noting that although Node offers access into details such as
   350  // line numbers, colums, and comments, the content when re-encoded will not
   351  // have its original textual representation preserved. An effort is made to
   352  // render the data plesantly, and to preserve comments near the data they
   353  // describe, though.
   354  //
   355  // Values that make use of the Node type interact with the yaml package in the
   356  // same way any other type would do, by encoding and decoding yaml data
   357  // directly or indirectly into them.
   358  //
   359  // For example:
   360  //
   361  //     var person struct {
   362  //             Name    string
   363  //             Address yaml.Node
   364  //     }
   365  //     err := yaml.Unmarshal(data, &person)
   366  // 
   367  // Or by itself:
   368  //
   369  //     var person Node
   370  //     err := yaml.Unmarshal(data, &person)
   371  //
   372  type Node struct {
   373  	// Kind defines whether the node is a document, a mapping, a sequence,
   374  	// a scalar value, or an alias to another node. The specific data type of
   375  	// scalar nodes may be obtained via the ShortTag and LongTag methods.
   376  	Kind  Kind
   377  
   378  	// Style allows customizing the apperance of the node in the tree.
   379  	Style Style
   380  
   381  	// Tag holds the YAML tag defining the data type for the value.
   382  	// When decoding, this field will always be set to the resolved tag,
   383  	// even when it wasn't explicitly provided in the YAML content.
   384  	// When encoding, if this field is unset the value type will be
   385  	// implied from the node properties, and if it is set, it will only
   386  	// be serialized into the representation if TaggedStyle is used or
   387  	// the implicit tag diverges from the provided one.
   388  	Tag string
   389  
   390  	// Value holds the unescaped and unquoted represenation of the value.
   391  	Value string
   392  
   393  	// Anchor holds the anchor name for this node, which allows aliases to point to it.
   394  	Anchor string
   395  
   396  	// Alias holds the node that this alias points to. Only valid when Kind is AliasNode.
   397  	Alias *Node
   398  
   399  	// Content holds contained nodes for documents, mappings, and sequences.
   400  	Content []*Node
   401  
   402  	// HeadComment holds any comments in the lines preceding the node and
   403  	// not separated by an empty line.
   404  	HeadComment string
   405  
   406  	// LineComment holds any comments at the end of the line where the node is in.
   407  	LineComment string
   408  
   409  	// FootComment holds any comments following the node and before empty lines.
   410  	FootComment string
   411  
   412  	// Line and Column hold the node position in the decoded YAML text.
   413  	// These fields are not respected when encoding the node.
   414  	Line   int
   415  	Column int
   416  }
   417  
   418  // IsZero returns whether the node has all of its fields unset.
   419  func (n *Node) IsZero() bool {
   420  	return n.Kind == 0 && n.Style == 0 && n.Tag == "" && n.Value == "" && n.Anchor == "" && n.Alias == nil && n.Content == nil &&
   421  		n.HeadComment == "" && n.LineComment == "" && n.FootComment == "" && n.Line == 0 && n.Column == 0
   422  }
   423  
   424  
   425  // LongTag returns the long form of the tag that indicates the data type for
   426  // the node. If the Tag field isn't explicitly defined, one will be computed
   427  // based on the node properties.
   428  func (n *Node) LongTag() string {
   429  	return longTag(n.ShortTag())
   430  }
   431  
   432  // ShortTag returns the short form of the YAML tag that indicates data type for
   433  // the node. If the Tag field isn't explicitly defined, one will be computed
   434  // based on the node properties.
   435  func (n *Node) ShortTag() string {
   436  	if n.indicatedString() {
   437  		return strTag
   438  	}
   439  	if n.Tag == "" || n.Tag == "!" {
   440  		switch n.Kind {
   441  		case MappingNode:
   442  			return mapTag
   443  		case SequenceNode:
   444  			return seqTag
   445  		case AliasNode:
   446  			if n.Alias != nil {
   447  				return n.Alias.ShortTag()
   448  			}
   449  		case ScalarNode:
   450  			tag, _ := resolve("", n.Value)
   451  			return tag
   452  		case 0:
   453  			// Special case to make the zero value convenient.
   454  			if n.IsZero() {
   455  				return nullTag
   456  			}
   457  		}
   458  		return ""
   459  	}
   460  	return shortTag(n.Tag)
   461  }
   462  
   463  func (n *Node) indicatedString() bool {
   464  	return n.Kind == ScalarNode &&
   465  		(shortTag(n.Tag) == strTag ||
   466  			(n.Tag == "" || n.Tag == "!") && n.Style&(SingleQuotedStyle|DoubleQuotedStyle|LiteralStyle|FoldedStyle) != 0)
   467  }
   468  
   469  // SetString is a convenience function that sets the node to a string value
   470  // and defines its style in a pleasant way depending on its content.
   471  func (n *Node) SetString(s string) {
   472  	n.Kind = ScalarNode
   473  	if utf8.ValidString(s) {
   474  		n.Value = s
   475  		n.Tag = strTag
   476  	} else {
   477  		n.Value = encodeBase64(s)
   478  		n.Tag = binaryTag
   479  	}
   480  	if strings.Contains(n.Value, "\n") {
   481  		n.Style = LiteralStyle
   482  	}
   483  }
   484  
   485  // --------------------------------------------------------------------------
   486  // Maintain a mapping of keys to structure field indexes
   487  
   488  // The code in this section was copied from mgo/bson.
   489  
   490  // structInfo holds details for the serialization of fields of
   491  // a given struct.
   492  type structInfo struct {
   493  	FieldsMap  map[string]fieldInfo
   494  	FieldsList []fieldInfo
   495  
   496  	// InlineMap is the number of the field in the struct that
   497  	// contains an ,inline map, or -1 if there's none.
   498  	InlineMap int
   499  
   500  	// InlineUnmarshalers holds indexes to inlined fields that
   501  	// contain unmarshaler values.
   502  	InlineUnmarshalers [][]int
   503  }
   504  
   505  type fieldInfo struct {
   506  	Key       string
   507  	Num       int
   508  	OmitEmpty bool
   509  	Flow      bool
   510  	// Id holds the unique field identifier, so we can cheaply
   511  	// check for field duplicates without maintaining an extra map.
   512  	Id int
   513  
   514  	// Inline holds the field index if the field is part of an inlined struct.
   515  	Inline []int
   516  }
   517  
   518  var structMap = make(map[reflect.Type]*structInfo)
   519  var fieldMapMutex sync.RWMutex
   520  var unmarshalerType reflect.Type
   521  
   522  func init() {
   523  	var v Unmarshaler
   524  	unmarshalerType = reflect.ValueOf(&v).Elem().Type()
   525  }
   526  
   527  func getStructInfo(st reflect.Type) (*structInfo, error) {
   528  	fieldMapMutex.RLock()
   529  	sinfo, found := structMap[st]
   530  	fieldMapMutex.RUnlock()
   531  	if found {
   532  		return sinfo, nil
   533  	}
   534  
   535  	n := st.NumField()
   536  	fieldsMap := make(map[string]fieldInfo)
   537  	fieldsList := make([]fieldInfo, 0, n)
   538  	inlineMap := -1
   539  	inlineUnmarshalers := [][]int(nil)
   540  	for i := 0; i != n; i++ {
   541  		field := st.Field(i)
   542  		if field.PkgPath != "" && !field.Anonymous {
   543  			continue // Private field
   544  		}
   545  
   546  		info := fieldInfo{Num: i}
   547  
   548  		tag := field.Tag.Get("yaml")
   549  		if tag == "" && strings.Index(string(field.Tag), ":") < 0 {
   550  			tag = string(field.Tag)
   551  		}
   552  		if tag == "-" {
   553  			continue
   554  		}
   555  
   556  		inline := false
   557  		fields := strings.Split(tag, ",")
   558  		if len(fields) > 1 {
   559  			for _, flag := range fields[1:] {
   560  				switch flag {
   561  				case "omitempty":
   562  					info.OmitEmpty = true
   563  				case "flow":
   564  					info.Flow = true
   565  				case "inline":
   566  					inline = true
   567  				default:
   568  					return nil, errors.New(fmt.Sprintf("unsupported flag %q in tag %q of type %s", flag, tag, st))
   569  				}
   570  			}
   571  			tag = fields[0]
   572  		}
   573  
   574  		if inline {
   575  			switch field.Type.Kind() {
   576  			case reflect.Map:
   577  				if inlineMap >= 0 {
   578  					return nil, errors.New("multiple ,inline maps in struct " + st.String())
   579  				}
   580  				if field.Type.Key() != reflect.TypeOf("") {
   581  					return nil, errors.New("option ,inline needs a map with string keys in struct " + st.String())
   582  				}
   583  				inlineMap = info.Num
   584  			case reflect.Struct, reflect.Ptr:
   585  				ftype := field.Type
   586  				for ftype.Kind() == reflect.Ptr {
   587  					ftype = ftype.Elem()
   588  				}
   589  				if ftype.Kind() != reflect.Struct {
   590  					return nil, errors.New("option ,inline may only be used on a struct or map field")
   591  				}
   592  				if reflect.PtrTo(ftype).Implements(unmarshalerType) {
   593  					inlineUnmarshalers = append(inlineUnmarshalers, []int{i})
   594  				} else {
   595  					sinfo, err := getStructInfo(ftype)
   596  					if err != nil {
   597  						return nil, err
   598  					}
   599  					for _, index := range sinfo.InlineUnmarshalers {
   600  						inlineUnmarshalers = append(inlineUnmarshalers, append([]int{i}, index...))
   601  					}
   602  					for _, finfo := range sinfo.FieldsList {
   603  						if _, found := fieldsMap[finfo.Key]; found {
   604  							msg := "duplicated key '" + finfo.Key + "' in struct " + st.String()
   605  							return nil, errors.New(msg)
   606  						}
   607  						if finfo.Inline == nil {
   608  							finfo.Inline = []int{i, finfo.Num}
   609  						} else {
   610  							finfo.Inline = append([]int{i}, finfo.Inline...)
   611  						}
   612  						finfo.Id = len(fieldsList)
   613  						fieldsMap[finfo.Key] = finfo
   614  						fieldsList = append(fieldsList, finfo)
   615  					}
   616  				}
   617  			default:
   618  				return nil, errors.New("option ,inline may only be used on a struct or map field")
   619  			}
   620  			continue
   621  		}
   622  
   623  		if tag != "" {
   624  			info.Key = tag
   625  		} else {
   626  			info.Key = strings.ToLower(field.Name)
   627  		}
   628  
   629  		if _, found = fieldsMap[info.Key]; found {
   630  			msg := "duplicated key '" + info.Key + "' in struct " + st.String()
   631  			return nil, errors.New(msg)
   632  		}
   633  
   634  		info.Id = len(fieldsList)
   635  		fieldsList = append(fieldsList, info)
   636  		fieldsMap[info.Key] = info
   637  	}
   638  
   639  	sinfo = &structInfo{
   640  		FieldsMap:          fieldsMap,
   641  		FieldsList:         fieldsList,
   642  		InlineMap:          inlineMap,
   643  		InlineUnmarshalers: inlineUnmarshalers,
   644  	}
   645  
   646  	fieldMapMutex.Lock()
   647  	structMap[st] = sinfo
   648  	fieldMapMutex.Unlock()
   649  	return sinfo, nil
   650  }
   651  
   652  // IsZeroer is used to check whether an object is zero to
   653  // determine whether it should be omitted when marshaling
   654  // with the omitempty flag. One notable implementation
   655  // is time.Time.
   656  type IsZeroer interface {
   657  	IsZero() bool
   658  }
   659  
   660  func isZero(v reflect.Value) bool {
   661  	kind := v.Kind()
   662  	if z, ok := v.Interface().(IsZeroer); ok {
   663  		if (kind == reflect.Ptr || kind == reflect.Interface) && v.IsNil() {
   664  			return true
   665  		}
   666  		return z.IsZero()
   667  	}
   668  	switch kind {
   669  	case reflect.String:
   670  		return len(v.String()) == 0
   671  	case reflect.Interface, reflect.Ptr:
   672  		return v.IsNil()
   673  	case reflect.Slice:
   674  		return v.Len() == 0
   675  	case reflect.Map:
   676  		return v.Len() == 0
   677  	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
   678  		return v.Int() == 0
   679  	case reflect.Float32, reflect.Float64:
   680  		return v.Float() == 0
   681  	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
   682  		return v.Uint() == 0
   683  	case reflect.Bool:
   684  		return !v.Bool()
   685  	case reflect.Struct:
   686  		vt := v.Type()
   687  		for i := v.NumField() - 1; i >= 0; i-- {
   688  			if vt.Field(i).PkgPath != "" {
   689  				continue // Private field
   690  			}
   691  			if !isZero(v.Field(i)) {
   692  				return false
   693  			}
   694  		}
   695  		return true
   696  	}
   697  	return false
   698  }
   699
View as plain text