| // Copyright 2016 The Vanadium 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 vdl |
| |
| import ( |
| "fmt" |
| ) |
| |
| // VDLRead uses dec to decode a value into vv. If vv isn't valid (i.e. has no |
| // type), it will be filled in the exact type of value read from the decoder. |
| // Otherwise the type of vv must be compatible with the type of the value read |
| // from the decoder. |
| func (vv *Value) VDLRead(dec Decoder) error { |
| if vv == nil { |
| return errReadIntoNilValue |
| } |
| ttWant := AnyType |
| if vv.IsValid() { |
| ttWant = vv.Type() |
| } |
| if err := dec.StartValue(ttWant); err != nil { |
| return err |
| } |
| if !vv.IsValid() { |
| // Initialize vv to the zero value of the exact type read from the decoder. |
| // It is as if vv were initialized with that type to begin with. The |
| // top-level any type is dropped. |
| switch { |
| case dec.IsOptional() && !dec.IsNil(): |
| *vv = *ZeroValue(OptionalType(dec.Type())) |
| default: |
| *vv = *ZeroValue(dec.Type()) |
| } |
| } |
| dec.IgnoreNextStartValue() |
| return vv.read(dec) |
| } |
| |
| func (vv *Value) read(dec Decoder) error { |
| if err := dec.StartValue(vv.Type()); err != nil { |
| return err |
| } |
| // Handle nil decoded values first, to simplify the rest of the cases. |
| if dec.IsNil() { |
| return vv.readFromNil(dec) |
| } |
| // Handle non-nil values. If vv is any or optional we need to treat it |
| // specially, since it needs to be assigned after the value is read. |
| vvFill, makeOptional := vv, false |
| switch { |
| case vv.Kind() == Any: |
| // Fill in a value of the type read from the decoder. |
| vvFill = ZeroValue(dec.Type()) |
| makeOptional = dec.IsOptional() |
| case vv.Kind() == Optional: |
| // Fill in a value of our elem type. |
| vvFill = ZeroValue(vv.Type().Elem()) |
| makeOptional = true |
| } |
| if err := vvFill.readNonNilValue(dec); err != nil { |
| return err |
| } |
| // Finished reading, handle any and optional cases. |
| if makeOptional { |
| vvFill = OptionalValue(vvFill) |
| } |
| if vv.Kind() == Any || vv.Kind() == Optional { |
| vv.Assign(vvFill) |
| } |
| return dec.FinishValue() |
| } |
| |
| func (vv *Value) readFromNil(dec Decoder) error { |
| // We've already checked for compatibility above, so we know that we're |
| // allowed to set the nil value. |
| switch { |
| case vv.Kind() == Any: |
| // Make sure that any(nil) and ?T(nil) are retained correctly in the any. |
| vv.Assign(ZeroValue(dec.Type())) |
| case vv.Kind() == Optional: |
| // Just set the optional to nil. |
| vv.Assign(nil) |
| default: |
| return fmt.Errorf("vdl: can't decode nil into non-any non-optional %v", vv.Type()) |
| } |
| return dec.FinishValue() |
| } |
| |
| func (vv *Value) readNonNilValue(dec Decoder) error { |
| if vv.Type().IsBytes() { |
| var val []byte |
| fixedLen := -1 |
| if vv.Kind() == Array { |
| fixedLen = vv.Type().Len() |
| val = make([]byte, fixedLen) |
| } |
| if err := dec.DecodeBytes(fixedLen, &val); err != nil { |
| return err |
| } |
| vv.AssignBytes(val) |
| return nil |
| } |
| switch vv.Kind() { |
| case Bool: |
| val, err := dec.DecodeBool() |
| if err != nil { |
| return err |
| } |
| vv.AssignBool(val) |
| return nil |
| case Byte, Uint16, Uint32, Uint64: |
| val, err := dec.DecodeUint(vv.Kind().BitLen()) |
| if err != nil { |
| return err |
| } |
| vv.AssignUint(val) |
| return nil |
| case Int8, Int16, Int32, Int64: |
| val, err := dec.DecodeInt(vv.Kind().BitLen()) |
| if err != nil { |
| return err |
| } |
| vv.AssignInt(val) |
| return nil |
| case Float32, Float64: |
| val, err := dec.DecodeFloat(vv.Kind().BitLen()) |
| if err != nil { |
| return err |
| } |
| vv.AssignFloat(val) |
| return nil |
| case String: |
| val, err := dec.DecodeString() |
| if err != nil { |
| return err |
| } |
| vv.AssignString(val) |
| return nil |
| case TypeObject: |
| val, err := dec.DecodeTypeObject() |
| if err != nil { |
| return err |
| } |
| vv.AssignTypeObject(val) |
| return nil |
| case Enum: |
| val, err := dec.DecodeString() |
| if err != nil { |
| return err |
| } |
| index := vv.Type().EnumIndex(val) |
| if index == -1 { |
| return fmt.Errorf("vdl: %v invalid enum label %q", vv.Type(), val) |
| } |
| vv.AssignEnumIndex(index) |
| return nil |
| case Array: |
| return vv.readArray(dec) |
| case List: |
| return vv.readList(dec) |
| case Set: |
| return vv.readSet(dec) |
| case Map: |
| return vv.readMap(dec) |
| case Struct: |
| return vv.readStruct(dec) |
| case Union: |
| return vv.readUnion(dec) |
| } |
| panic(fmt.Errorf("vdl: unhandled type %v in VDLRead", vv.Type())) |
| } |
| |
| func (vv *Value) readArray(dec Decoder) error { |
| index := 0 |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done != (index >= vv.Type().Len()): |
| return fmt.Errorf("array len mismatch, done:%v index:%d len:%d %v", done, index, vv.Type().Len(), vv.Type()) |
| case done: |
| return nil |
| } |
| if err := vv.Index(index).read(dec); err != nil { |
| return err |
| } |
| index++ |
| } |
| } |
| |
| func (vv *Value) readList(dec Decoder) error { |
| switch len := dec.LenHint(); { |
| case len >= 0: |
| vv.AssignLen(len) |
| default: |
| // Assign 0 length when we don't have a hint. |
| vv.AssignLen(0) |
| } |
| index := 0 |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return nil |
| } |
| if needLen := index + 1; needLen > vv.Len() { |
| var cap int |
| if needLen <= 1024 { |
| cap = needLen * 2 |
| } else { |
| cap = needLen + needLen/4 |
| } |
| // Grow the underlying buffer. The first AssignLen grows the buffer to |
| // the capacity, while the second AssignLen sets the actual length. |
| // |
| // TODO(toddw): Consider changing the Value API to either add an Append |
| // method, or to allow the user to explicitly manage the capacity. |
| vv.AssignLen(cap) |
| vv.AssignLen(needLen) |
| } |
| if err := vv.Index(index).read(dec); err != nil { |
| return err |
| } |
| index++ |
| } |
| } |
| |
| func (vv *Value) readSet(dec Decoder) error { |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return nil |
| } |
| key := ZeroValue(vv.Type().Key()) |
| if err := key.read(dec); err != nil { |
| return err |
| } |
| vv.AssignSetKey(key) |
| } |
| } |
| |
| func (vv *Value) readMap(dec Decoder) error { |
| for { |
| switch done, err := dec.NextEntry(); { |
| case err != nil: |
| return err |
| case done: |
| return nil |
| } |
| key := ZeroValue(vv.Type().Key()) |
| if err := key.read(dec); err != nil { |
| return err |
| } |
| elem := ZeroValue(vv.Type().Elem()) |
| if err := elem.read(dec); err != nil { |
| return err |
| } |
| vv.AssignMapIndex(key, elem) |
| } |
| } |
| |
| func (vv *Value) readStruct(dec Decoder) error { |
| // Reset to zero struct, since fields may be missing. |
| vv.Assign(nil) |
| tt, decType := vv.Type(), dec.Type() |
| for { |
| index, err := dec.NextField() |
| switch { |
| case err != nil: |
| return err |
| case index == -1: |
| return nil |
| } |
| if decType != tt { |
| index = tt.FieldIndexByName(decType.Field(index).Name) |
| if index == -1 { |
| if err := dec.SkipValue(); err != nil { |
| return err |
| } |
| continue |
| } |
| } |
| if err := vv.StructField(index).read(dec); err != nil { |
| return err |
| } |
| } |
| } |
| |
| func (vv *Value) readUnion(dec Decoder) error { |
| tt, decType := vv.Type(), dec.Type() |
| index, err := dec.NextField() |
| switch { |
| case err != nil: |
| return err |
| case index == -1: |
| return fmt.Errorf("missing field in union %v, from %v", tt, decType) |
| } |
| var ttField Field |
| if decType == tt { |
| ttField = tt.Field(index) |
| } else { |
| name := decType.Field(index).Name |
| ttField, index = tt.FieldByName(name) |
| if index == -1 { |
| return fmt.Errorf("field %q not in union %v, from %v", name, tt, decType) |
| } |
| } |
| vvElem := ZeroValue(ttField.Type) |
| if err := vvElem.read(dec); err != nil { |
| return err |
| } |
| vv.AssignField(index, vvElem) |
| switch index, err := dec.NextField(); { |
| case err != nil: |
| return err |
| case index != -1: |
| return fmt.Errorf("extra field %d in union %v, from %v", index, tt, decType) |
| } |
| return nil |
| } |