Method assignArray

unmarshaler.go:1883–1960

(v reflect.Value, expr *unstable.Node, value *unstable.Node)

}

func (d *decoder) assignArray(v reflect.Value, expr *unstable.Node, value *unstable.Node) (reflect.Value, error) {
	// Count the elements to allocate the target in one go.
	count := 0
	cit := value.Children()
	for cit.Next() {
		if cit.Node().Kind != unstable.Comment {
			count++
		}
	}

	switch v.Kind() {
	case reflect.Slice:
		// Allocate the backing array once at its final length and assign each
		// element in place. This avoids a reflect.New allocation per element
		// and the repeated growth checks of reflect.Append.
		slice := reflect.MakeSlice(v.Type(), count, count)
		i := 0
		it := value.Children()
		for it.Next() {
			n := it.Node()
			if n.Kind == unstable.Comment {
				continue
			}
			elem := slice.Index(i)
			nv, err := d.assignValue(elem, nil, n)
			if err != nil {
				return reflect.Value{}, err
			}
			if nv.IsValid() {
				elem.Set(nv)
			}
			i++
		}
		return slice, nil
	case reflect.Array:
		it := value.Children()
		i := 0
		for it.Next() {
			n := it.Node()
			if n.Kind == unstable.Comment {
				continue
			}
			if i >= v.Len() {
				// Extra elements are dropped when the target array is too
				// small.
				break
			}
			elem := v.Index(i)
			nv, err := d.assignValue(elem, nil, n)
			if err != nil {
				return reflect.Value{}, err
			}
			elem.Set(nv)
			i++
		}
		return v, nil
	case reflect.Interface:
		// Build the []interface{} natively: each element is decoded straight