| // 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 |
| |
| // The "fast" Decoder ReadValue* and NextEntryValue* methods aren't actually |
| // fast, they just call the appropriate methods in sequence. |
| |
| func (d *pipeDecoder) ReadValueBool() (bool, error) { |
| if err := d.StartValue(BoolType); err != nil { |
| return false, err |
| } |
| value, err := d.DecodeBool() |
| if err != nil { |
| return false, err |
| } |
| return value, d.FinishValue() |
| } |
| |
| func (d *pipeDecoder) ReadValueString() (string, error) { |
| if err := d.StartValue(StringType); err != nil { |
| return "", err |
| } |
| value, err := d.DecodeString() |
| if err != nil { |
| return "", err |
| } |
| return value, d.FinishValue() |
| } |
| |
| func (d *pipeDecoder) ReadValueUint(bitlen int) (uint64, error) { |
| if err := d.StartValue(Uint64Type); err != nil { |
| return 0, err |
| } |
| value, err := d.DecodeUint(bitlen) |
| if err != nil { |
| return 0, err |
| } |
| return value, d.FinishValue() |
| } |
| |
| func (d *pipeDecoder) ReadValueInt(bitlen int) (int64, error) { |
| if err := d.StartValue(Int64Type); err != nil { |
| return 0, err |
| } |
| value, err := d.DecodeInt(bitlen) |
| if err != nil { |
| return 0, err |
| } |
| return value, d.FinishValue() |
| } |
| |
| func (d *pipeDecoder) ReadValueFloat(bitlen int) (float64, error) { |
| if err := d.StartValue(Float64Type); err != nil { |
| return 0, err |
| } |
| value, err := d.DecodeFloat(bitlen) |
| if err != nil { |
| return 0, err |
| } |
| return value, d.FinishValue() |
| } |
| |
| func (d *pipeDecoder) ReadValueTypeObject() (*Type, error) { |
| if err := d.StartValue(TypeObjectType); err != nil { |
| return nil, err |
| } |
| value, err := d.DecodeTypeObject() |
| if err != nil { |
| return nil, err |
| } |
| return value, d.FinishValue() |
| } |
| |
| func (d *pipeDecoder) ReadValueBytes(fixedLen int, x *[]byte) error { |
| if err := d.StartValue(ttByteList); err != nil { |
| return err |
| } |
| if err := d.DecodeBytes(fixedLen, x); err != nil { |
| return err |
| } |
| return d.FinishValue() |
| } |
| |
| func (d *pipeDecoder) NextEntryValueBool() (done bool, _ bool, _ error) { |
| if done, err := d.NextEntry(); done || err != nil { |
| return done, false, err |
| } |
| value, err := d.ReadValueBool() |
| return false, value, err |
| } |
| |
| func (d *pipeDecoder) NextEntryValueString() (done bool, _ string, _ error) { |
| if done, err := d.NextEntry(); done || err != nil { |
| return done, "", err |
| } |
| value, err := d.ReadValueString() |
| return false, value, err |
| } |
| |
| func (d *pipeDecoder) NextEntryValueUint(bitlen int) (done bool, _ uint64, _ error) { |
| if done, err := d.NextEntry(); done || err != nil { |
| return done, 0, err |
| } |
| value, err := d.ReadValueUint(bitlen) |
| return false, value, err |
| } |
| |
| func (d *pipeDecoder) NextEntryValueInt(bitlen int) (done bool, _ int64, _ error) { |
| if done, err := d.NextEntry(); done || err != nil { |
| return done, 0, err |
| } |
| value, err := d.ReadValueInt(bitlen) |
| return false, value, err |
| } |
| |
| func (d *pipeDecoder) NextEntryValueFloat(bitlen int) (done bool, _ float64, _ error) { |
| if done, err := d.NextEntry(); done || err != nil { |
| return done, 0, err |
| } |
| value, err := d.ReadValueFloat(bitlen) |
| return false, value, err |
| } |
| |
| func (d *pipeDecoder) NextEntryValueTypeObject() (done bool, _ *Type, _ error) { |
| if done, err := d.NextEntry(); done || err != nil { |
| return done, nil, err |
| } |
| value, err := d.ReadValueTypeObject() |
| return false, value, err |
| } |
| |
| // The "fast" Encoder WriteValue*, NextEntryValue* and NextFieldValue* methods |
| // aren't actually fast, they just call the appropriate methods in sequence. |
| |
| func (e *pipeEncoder) WriteValueBool(tt *Type, value bool) error { |
| if err := e.StartValue(tt); err != nil { |
| return err |
| } |
| if err := e.EncodeBool(value); err != nil { |
| return err |
| } |
| return e.FinishValue() |
| } |
| |
| func (e *pipeEncoder) WriteValueString(tt *Type, value string) error { |
| if err := e.StartValue(tt); err != nil { |
| return err |
| } |
| if err := e.EncodeString(value); err != nil { |
| return err |
| } |
| return e.FinishValue() |
| } |
| |
| func (e *pipeEncoder) WriteValueUint(tt *Type, value uint64) error { |
| if err := e.StartValue(tt); err != nil { |
| return err |
| } |
| if err := e.EncodeUint(value); err != nil { |
| return err |
| } |
| return e.FinishValue() |
| } |
| |
| func (e *pipeEncoder) WriteValueInt(tt *Type, value int64) error { |
| if err := e.StartValue(tt); err != nil { |
| return err |
| } |
| if err := e.EncodeInt(value); err != nil { |
| return err |
| } |
| return e.FinishValue() |
| } |
| |
| func (e *pipeEncoder) WriteValueFloat(tt *Type, value float64) error { |
| if err := e.StartValue(tt); err != nil { |
| return err |
| } |
| if err := e.EncodeFloat(value); err != nil { |
| return err |
| } |
| return e.FinishValue() |
| } |
| |
| func (e *pipeEncoder) WriteValueTypeObject(value *Type) error { |
| if err := e.StartValue(TypeObjectType); err != nil { |
| return err |
| } |
| if err := e.EncodeTypeObject(value); err != nil { |
| return err |
| } |
| return e.FinishValue() |
| } |
| |
| func (e *pipeEncoder) WriteValueBytes(tt *Type, value []byte) error { |
| if err := e.StartValue(tt); err != nil { |
| return err |
| } |
| if err := e.EncodeBytes(value); err != nil { |
| return err |
| } |
| return e.FinishValue() |
| } |
| |
| func (e *pipeEncoder) NextEntryValueBool(tt *Type, value bool) error { |
| if err := e.NextEntry(false); err != nil { |
| return err |
| } |
| return e.WriteValueBool(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextEntryValueString(tt *Type, value string) error { |
| if err := e.NextEntry(false); err != nil { |
| return err |
| } |
| return e.WriteValueString(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextEntryValueUint(tt *Type, value uint64) error { |
| if err := e.NextEntry(false); err != nil { |
| return err |
| } |
| return e.WriteValueUint(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextEntryValueInt(tt *Type, value int64) error { |
| if err := e.NextEntry(false); err != nil { |
| return err |
| } |
| return e.WriteValueInt(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextEntryValueFloat(tt *Type, value float64) error { |
| if err := e.NextEntry(false); err != nil { |
| return err |
| } |
| return e.WriteValueFloat(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextEntryValueTypeObject(value *Type) error { |
| if err := e.NextEntry(false); err != nil { |
| return err |
| } |
| return e.WriteValueTypeObject(value) |
| } |
| |
| func (e *pipeEncoder) NextEntryValueBytes(tt *Type, value []byte) error { |
| if err := e.NextEntry(false); err != nil { |
| return err |
| } |
| return e.WriteValueBytes(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextFieldValueBool(index int, tt *Type, value bool) error { |
| if err := e.NextField(index); err != nil { |
| return err |
| } |
| return e.WriteValueBool(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextFieldValueString(index int, tt *Type, value string) error { |
| if err := e.NextField(index); err != nil { |
| return err |
| } |
| return e.WriteValueString(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextFieldValueUint(index int, tt *Type, value uint64) error { |
| if err := e.NextField(index); err != nil { |
| return err |
| } |
| return e.WriteValueUint(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextFieldValueInt(index int, tt *Type, value int64) error { |
| if err := e.NextField(index); err != nil { |
| return err |
| } |
| return e.WriteValueInt(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextFieldValueFloat(index int, tt *Type, value float64) error { |
| if err := e.NextField(index); err != nil { |
| return err |
| } |
| return e.WriteValueFloat(tt, value) |
| } |
| |
| func (e *pipeEncoder) NextFieldValueTypeObject(index int, value *Type) error { |
| if err := e.NextField(index); err != nil { |
| return err |
| } |
| return e.WriteValueTypeObject(value) |
| } |
| |
| func (e *pipeEncoder) NextFieldValueBytes(index int, tt *Type, value []byte) error { |
| if err := e.NextField(index); err != nil { |
| return err |
| } |
| return e.WriteValueBytes(tt, value) |
| } |