Flip to new vdl/vom coder implementation.
The purpose of this is two-fold:
1) Simplify the implementation of vdl/vom, so it's simpler to
implement in different langauges, and also easier to ensure
correctness. The new vdl.{En,De}coder interfaces are the basis
of this, and replace the old vdl.Target interface.
2) Improve the performance of vom. By simplifying the
implementation we've made it easier to speed things up.
Note that the new implementation already exists in the codebase.
This CL just makes a minimal change to flip everything over.
Thus it's easy to revert if we have to. We will remove the old
implementation after we're confident we don't need to revert.
The new vom implementation only supports version 81. The old
version 80 has been dropped. Note that the default has been vom
version 81 since Feb 2016.
My initial prototypes yielded even better results, but we had to
sacrifice some of these gains in the short-term in order to get
everything working (i.e. code-generation, reflection support,
vom.RawBytes, vdl.Value, vdl.Convert, etc) while keeping the old
vdl.Target based implementation working. We'll re-introduce
those speedups after we've removed the old implementation.
Here are some numbers. Everything gets faster, except:
* Encoding vom.RawBytes gets much slower, because of an annoying
subtlety regarding optional types. We will fix this later.
* The rpc mux benchmarks get slightly slower. I don't know why.
VOM micro-benchmarks
old ns/op new ns/op delta
VomEncodeRequest 2925 1866 -36.21%
VomEncodeResponse 1820 833 -54.23%
VomEncodeCustomer 40330 36031 -10.66%
VomEncoder1Customer 40309 36014 -10.66%
VomEncoder1000Customer 3142349 2046473 -34.87%
VomEncoder1000RawBytes 294401 403669 +37.12%
VomDecodeRequest 4552 2628 -42.27%
VomDecodeResponse 2027 795 -60.78%
VomDecodeCustomer 5805 5107 -12.02%
VomDecoder1Customer 192649 172753 -10.33%
VomDecoder1000Customer 4558302 2992711 -34.35%
VomDecoder1000RawBytes 972727 517747 -46.77%
RPC benchmarks
old ns/op new ns/op delta
____1B 296491 284414 -4.07%
___1KB 325928 297664 -8.67%
_100KB 1326710 1258173 -5.17%
____1B_ClientExpiryCav 317818 306347 -3.61%
___1KB_ClientExpiryCav 321261 302726 -5.77%
_100KB_ClientExpiryCav 1256931 1201326 -4.42%
____1B_ServerExpiryCav 342073 307126 -10.22%
___1KB_ServerExpiryCav 365351 318310 -12.88%
_100KB_ServerExpiryCav 1343229 1209946 -9.92%
____1_chunk_____1B 342637 321144 -6.27%
____1_chunk____1KB 349254 324237 -7.16%
____1_chunk__100KB 1224160 1163401 -4.96%
___10_chunk_____1B 729852 617652 -15.37%
___10_chunk____1KB 807691 696424 -13.78%
___10_chunk__100KB 5225549 4750544 -9.09%
__100_chunk_____1B 4273110 3333279 -21.99%
__100_chunk____1KB 4829135 4010860 -16.94%
__100_chunk__100KB 43560028 40342297 -7.39%
___1K_chunk_____1B 39160789 29966919 -23.48%
___1K_chunk____1KB 44271650 37794217 -14.63%
___1K_chunk__100KB 431233078 394271852 -8.57%
__per_chunk____1B 38471 29939 -22.18%
__per_chunk___1KB 43828 36413 -16.92%
__per_chunk_100KB 422104 374219 -11.34%
___10B_mux__100_chunks___1KB 452887 467271 +3.18%
___10B_mux__100_chunks__10KB 490306 493584 +0.67%
___10B_mux___1K_chunks___1KB 452046 476033 +5.31%
___10B_mux___1K_chunks__10KB 494417 507299 +2.61%
___1KB_mux__100_chunks___1KB 475109 493633 +3.90%
___1KB_mux__100_chunks__10KB 510881 506461 -0.87%
___1KB_mux___1K_chunks___1KB 499237 497410 -0.37%
___1KB_mux___1K_chunks__10KB 518693 519869 +0.23%
ConnectionEstablishment 4999990 4514393 -9.71%
ProxiedConnectionEstablishment 10075409 9126877 -9.41%
PrivateConnectionEstablishment1 43243555 41965076 -2.96%
PrivateConnectionEstablishment3 44434825 41787868 -5.96%
Change-Id: I000867a3a0cfa81003c9af9ec5e54c1c07bd105d
diff --git a/syncbase/watch_stream.go b/syncbase/watch_stream.go
index 15cb28b..ff23b8f 100644
--- a/syncbase/watch_stream.go
+++ b/syncbase/watch_stream.go
@@ -6,14 +6,12 @@
import (
"fmt"
- "reflect"
"sync"
"v.io/v23/context"
wire "v.io/v23/services/syncbase"
"v.io/v23/services/watch"
"v.io/v23/syncbase/util"
- "v.io/v23/vdl"
"v.io/v23/verror"
)
@@ -106,12 +104,8 @@
}
// Parse the store change.
var storeChange wire.StoreChange
- rtarget, err := vdl.ReflectTarget(reflect.ValueOf(&storeChange))
- if err != nil {
- panic(err)
- }
- if err := c.Value.FillVDLTarget(rtarget, c.Value.Type); err != nil {
- panic(err)
+ if err := c.Value.ToValue(&storeChange); err != nil {
+ panic(fmt.Errorf("ToValue failed: %v, RawBytes: %#v", err, c.Value))
}
// Parse the state.
var changeType ChangeType
diff --git a/vdl/target.go b/vdl/target.go
index cc9af88..f2e300c 100644
--- a/vdl/target.go
+++ b/vdl/target.go
@@ -132,7 +132,7 @@
// ReflectTarget(reflect.ValueOf(dst)).FromReflect(reflect.ValueOf(src)).
func Convert(dst, src interface{}) error {
// TODO(bprosnitz) Flip useOldConvert=false to enable the new convert.
- const useOldConvert = true
+ const useOldConvert = false
if useOldConvert {
target, err := ReflectTarget(reflect.ValueOf(dst))
if err != nil {
@@ -155,7 +155,7 @@
// ValueFromReflect returns the value corresponding to rv.
func ValueFromReflect(rv reflect.Value) (*Value, error) {
- const useOldConvert = true
+ const useOldConvert = false
if useOldConvert {
var result *Value
target, err := ReflectTarget(reflect.ValueOf(&result))
diff --git a/vom/.api b/vom/.api
index a98f599..4376a6d 100644
--- a/vom/.api
+++ b/vom/.api
@@ -55,19 +55,16 @@
pkg vom, func NewVersionedEncoder(Version, io.Writer) *Encoder
pkg vom, func NewVersionedEncoderWithTypeEncoder(Version, io.Writer, *TypeEncoder) *Encoder
pkg vom, func NewVersionedTypeEncoder(Version, io.Writer) *TypeEncoder
-pkg vom, func NewVersionedXEncoder(Version, io.Writer) *XEncoder
-pkg vom, func NewVersionedXEncoderWithTypeEncoder(Version, io.Writer, *TypeEncoder) *XEncoder
-pkg vom, func NewXDecoder(io.Reader) *XDecoder
-pkg vom, func NewXDecoderWithTypeDecoder(io.Reader, *TypeDecoder) *XDecoder
-pkg vom, func NewXEncoder(io.Writer) *XEncoder
-pkg vom, func NewXEncoderWithTypeEncoder(io.Writer, *TypeEncoder) *XEncoder
+pkg vom, func NewVersionedZEncoder(Version, io.Writer) *ZEncoder
+pkg vom, func NewVersionedZEncoderWithTypeEncoder(Version, io.Writer, *TypeEncoder) *ZEncoder
+pkg vom, func NewZDecoder(io.Reader) *ZDecoder
+pkg vom, func NewZDecoderWithTypeDecoder(io.Reader, *TypeDecoder) *ZDecoder
+pkg vom, func NewZEncoder(io.Writer) *ZEncoder
+pkg vom, func NewZEncoderWithTypeEncoder(io.Writer, *TypeEncoder) *ZEncoder
pkg vom, func RawBytesFromValue(interface{}) (*RawBytes, error)
pkg vom, func RawBytesOf(interface{}) *RawBytes
pkg vom, func VDLReadPrimitive(vdl.Decoder, *Primitive) error
pkg vom, func VersionedEncode(Version, interface{}) ([]byte, error)
-pkg vom, func VersionedXEncode(Version, interface{}) ([]byte, error)
-pkg vom, func XDecode([]byte, interface{}) error
-pkg vom, func XEncode(interface{}) ([]byte, error)
pkg vom, func XRawBytesFromValue(interface{}) (*RawBytes, error)
pkg vom, method (*ControlKind) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vom, method (*ControlKind) MakeVDLTarget() vdl.Target
@@ -75,6 +72,7 @@
pkg vom, method (*ControlKind) VDLRead(vdl.Decoder) error
pkg vom, method (*ControlKindTarget) FromEnumLabel(string, *vdl.Type) error
pkg vom, method (*Decoder) Decode(interface{}) error
+pkg vom, method (*Decoder) Decoder() vdl.Decoder
pkg vom, method (*Decoder) Ignore() error
pkg vom, method (*DumpAtom) FillVDLTarget(vdl.Target, *vdl.Type) error
pkg vom, method (*DumpAtom) MakeVDLTarget() vdl.Target
@@ -94,6 +92,7 @@
pkg vom, method (*Dumper) Status()
pkg vom, method (*Dumper) Write([]byte) (int, error)
pkg vom, method (*Encoder) Encode(interface{}) error
+pkg vom, method (*Encoder) Encoder() vdl.Encoder
pkg vom, method (*PrimitiveTarget) FinishField(vdl.Target, vdl.Target) error
pkg vom, method (*PrimitiveTarget) FinishFields(vdl.FieldsTarget) error
pkg vom, method (*PrimitiveTarget) StartField(string) (vdl.Target, vdl.Target, error)
@@ -122,11 +121,9 @@
pkg vom, method (*VersionTarget) FromFloat(float64, *vdl.Type) error
pkg vom, method (*VersionTarget) FromInt(int64, *vdl.Type) error
pkg vom, method (*VersionTarget) FromUint(uint64, *vdl.Type) error
-pkg vom, method (*XDecoder) Decode(interface{}) error
-pkg vom, method (*XDecoder) Decoder() vdl.Decoder
-pkg vom, method (*XDecoder) Ignore() error
-pkg vom, method (*XEncoder) Encode(interface{}) error
-pkg vom, method (*XEncoder) Encoder() vdl.Encoder
+pkg vom, method (*ZDecoder) Decode(interface{}) error
+pkg vom, method (*ZDecoder) Ignore() error
+pkg vom, method (*ZEncoder) Encode(interface{}) error
pkg vom, method (ControlKind) String() string
pkg vom, method (ControlKind) VDLIsZero() bool
pkg vom, method (ControlKind) VDLWrite(vdl.Encoder) error
@@ -265,7 +262,7 @@
pkg vom, type VersionTarget struct
pkg vom, type VersionTarget struct, Value *Version
pkg vom, type VersionTarget struct, embedded vdl.TargetBase
-pkg vom, type XDecoder struct
-pkg vom, type XEncoder struct
+pkg vom, type ZDecoder struct
+pkg vom, type ZEncoder struct
pkg vom, var ControlKindAll [...]ControlKind
pkg vom, var DumpKindAll [...]DumpKind
diff --git a/vom/binary_util.go b/vom/binary_util.go
index 22bd8b4..196cc8f 100644
--- a/vom/binary_util.go
+++ b/vom/binary_util.go
@@ -13,7 +13,7 @@
)
// TODO(toddw) Reduce the number of functions and optimize.
-const pkgPath = "v.io/v23/vom3"
+const pkgPath = "v.io/v23/vom"
var (
errInvalid = verror.Register(pkgPath+".errInvalid", verror.NoRetry, "{1:}{2:} vom: invalid encoding{:_}")
diff --git a/vom/convert_test.go b/vom/convert_test.go
index 961901b..06ffb52 100644
--- a/vom/convert_test.go
+++ b/vom/convert_test.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build newvdltests
-
package vom_test
import (
@@ -105,12 +103,12 @@
func testConvertCoder(target, source interface{}) error {
var buf bytes.Buffer
- enc := vom.NewXEncoder(&buf)
+ enc := vom.NewEncoder(&buf)
if err := enc.Encode(source); err != nil {
return fmt.Errorf("Encode failed: %v", err)
}
data := buf.Bytes()
- dec := vom.NewXDecoder(&buf)
+ dec := vom.NewDecoder(&buf)
if err := dec.Decode(target); err != nil {
return fmt.Errorf("Decode failed: %v\nDATA %x", err, data)
}
@@ -118,11 +116,11 @@
}
func testConvertSingleShot(target, source interface{}) error {
- data, err := vom.XEncode(source)
+ data, err := vom.Encode(source)
if err != nil {
return fmt.Errorf("(single-shot) Encode failed: %v", err)
}
- if err := vom.XDecode(data, target); err != nil {
+ if err := vom.Decode(data, target); err != nil {
return fmt.Errorf("(single-shot) Decode failed: %v\nDATA %x", err, data)
}
return nil
@@ -130,12 +128,12 @@
func testConvertWithTypeCoder(target, source interface{}, encT *vom.TypeEncoder, decT *vom.TypeDecoder) error {
var buf bytes.Buffer
- enc := vom.NewXEncoderWithTypeEncoder(&buf, encT)
+ enc := vom.NewEncoderWithTypeEncoder(&buf, encT)
if err := enc.Encode(source); err != nil {
return fmt.Errorf("(with TypeEncoder) Encode failed: %v", err)
}
data := buf.Bytes()
- dec := vom.NewXDecoderWithTypeDecoder(&buf, decT)
+ dec := vom.NewDecoderWithTypeDecoder(&buf, decT)
if err := dec.Decode(target); err != nil {
return fmt.Errorf("(with TypeDecoder) Decode failed: %v\nDATA %x", err, data)
}
diff --git a/vom/decoder.go b/vom/decoder.go
index 161860e..d841305 100644
--- a/vom/decoder.go
+++ b/vom/decoder.go
@@ -25,9 +25,9 @@
errInvalidAnyIndex = verror.Register(pkgPath+".errInvalidAnyIndex", verror.NoRetry, "{1:}{2:} vom: value referenced invalid index into anyLen table {:_}")
)
-// Decoder manages the receipt and unmarshalling of typed values from the other
+// ZDecoder manages the receipt and unmarshalling of typed values from the other
// side of a connection.
-type Decoder struct {
+type ZDecoder struct {
typeDec *TypeDecoder
hasSeparateTypeDec bool // TODO(bprosnitz) This should probably be removed.
@@ -48,26 +48,26 @@
return io.TeeReader(r, NewDumper(NewDumpWriter(os.Stdout)))
}
-// NewDecoder returns a new Decoder that reads from the given reader. The
-// Decoder understands all formats generated by the Encoder.
-func NewDecoder(r io.Reader) *Decoder {
+// NewZDecoder returns a new ZDecoder that reads from the given reader. The
+// ZDecoder understands all formats generated by the Encoder.
+func NewZDecoder(r io.Reader) *ZDecoder {
// When the TypeDecoder isn't shared, we always decode type messages in
// Decoder.decodeValueType() and feed them to the TypeDecoder. That is,
// the TypeDecoder will never read messages from the buffer. So we pass
// a nil buffer to newTypeDecoder.
buf := newDecbuf(r)
typeDec := newTypeDecoderInternal(buf)
- return &Decoder{
+ return &ZDecoder{
buf: buf,
typeDec: typeDec,
hasSeparateTypeDec: false,
}
}
-// NewDecoderWithTypeDecoder returns a new Decoder that reads from the given
+// NewZDecoderWithTypeDecoder returns a new Decoder that reads from the given
// reader. Types will be decoded separately through the given typeDec.
-func NewDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *Decoder {
- return &Decoder{
+func NewZDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *ZDecoder {
+ return &ZDecoder{
buf: newDecbuf(r),
typeDec: typeDec,
hasSeparateTypeDec: true,
@@ -89,7 +89,7 @@
// subsequently passed to an Encoder for transcoding.
//
// Decode(nil) always returns an error. Use Ignore() to ignore the next value.
-func (d *Decoder) Decode(v interface{}) error {
+func (d *ZDecoder) Decode(v interface{}) error {
if v == nil {
return verror.New(errDecodeNil, nil)
}
@@ -100,7 +100,7 @@
return d.decodeToTarget(target)
}
-func (d *Decoder) decodeTypeDefs() error {
+func (d *ZDecoder) decodeTypeDefs() error {
if !d.hasSeparateTypeDec {
for {
typeNext, err := d.typeIsNext()
@@ -118,7 +118,7 @@
return nil
}
-func (d *Decoder) decodeToTarget(target vdl.Target) error {
+func (d *ZDecoder) decodeToTarget(target vdl.Target) error {
if err := d.decodeTypeDefs(); err != nil {
return err
}
@@ -149,7 +149,7 @@
}
// Ignore ignores the next value from the reader.
-func (d *Decoder) Ignore() error {
+func (d *ZDecoder) Ignore() error {
if err := d.decodeTypeDefs(); err != nil {
return err
}
@@ -174,7 +174,7 @@
// decodeWireType decodes the next type definition message and returns its
// type id.
-func (d *Decoder) decodeWireType(wt *wireType) (TypeId, error) {
+func (d *ZDecoder) decodeWireType(wt *wireType) (TypeId, error) {
tid, err := d.nextMessage()
if err != nil {
return 0, err
@@ -191,7 +191,7 @@
}
// peekValueByteLen returns the byte length of the next value.
-func (d *Decoder) peekValueByteLen(tt *vdl.Type) (int, error) {
+func (d *ZDecoder) peekValueByteLen(tt *vdl.Type) (int, error) {
if hasChunkLen(tt) {
// Use the explicit message length.
return d.buf.lim, nil
@@ -223,7 +223,7 @@
}
}
-func (d *Decoder) decodeRaw(tt *vdl.Type, valLen int, raw *RawBytes) error {
+func (d *ZDecoder) decodeRaw(tt *vdl.Type, valLen int, raw *RawBytes) error {
raw.Version = d.buf.version
raw.Type = tt
raw.Data = make([]byte, valLen)
@@ -250,7 +250,7 @@
HackGetRv() reflect.Value
}
-func (d *Decoder) tryDecodeRaw(tt *vdl.Type, valLen int, rv reflect.Value) (isRawBytes bool, _ error) {
+func (d *ZDecoder) tryDecodeRaw(tt *vdl.Type, valLen int, rv reflect.Value) (isRawBytes bool, _ error) {
// Dereference pointers down to at most one remaining *.
for rv.IsValid() && rv.Kind() == reflect.Ptr && rv.Elem().IsValid() && rv.Elem().Kind() == reflect.Ptr {
rv = rv.Elem()
@@ -274,7 +274,7 @@
}
// decodeValue decodes the rest of the message assuming type tt.
-func (d *Decoder) decodeValue(tt *vdl.Type, target vdl.Target) error {
+func (d *ZDecoder) decodeValue(tt *vdl.Type, target vdl.Target) error {
ttFrom := tt
if tt.Kind() == vdl.Optional {
// If the type is optional, we expect to see either WireCtrlNil or the actual
@@ -548,7 +548,7 @@
}
}
-func (d *Decoder) readAnyHeader() (*vdl.Type, int, error) {
+func (d *ZDecoder) readAnyHeader() (*vdl.Type, int, error) {
// Read either WireCtrlNil or the index of the referenced type id.
typeIndex, ctrl, err := binaryDecodeUintWithControl(d.buf)
switch {
@@ -587,7 +587,7 @@
// ignoreValue ignores the rest of the value of type t. This is used to ignore
// unknown struct fields.
-func (d *Decoder) ignoreValue(tt *vdl.Type) error {
+func (d *ZDecoder) ignoreValue(tt *vdl.Type) error {
// TODO(toddw): How about ignoring optional values?
if tt.IsBytes() {
len, err := binaryDecodeLenOrArrayLen(d.buf, tt)
@@ -686,7 +686,7 @@
}
}
-func (d *Decoder) nextMessage() (TypeId, error) {
+func (d *ZDecoder) nextMessage() (TypeId, error) {
if leftover := d.buf.RemoveLimit(); leftover > 0 {
return 0, verror.New(errLeftOverBytes, nil, leftover)
}
@@ -787,7 +787,7 @@
return tid, nil
}
-func (d *Decoder) typeIsNext() (bool, error) {
+func (d *ZDecoder) typeIsNext() (bool, error) {
if d.buf.version == 0 {
version, err := d.buf.ReadByte()
if err != nil {
@@ -805,7 +805,7 @@
return mid < 0 || cr == WireCtrlTypeIncomplete, nil
}
-func (d *Decoder) endMessage() error {
+func (d *ZDecoder) endMessage() error {
if leftover := d.buf.RemoveLimit(); leftover > 0 {
return verror.New(errLeftOverBytes, nil, leftover)
}
@@ -818,7 +818,7 @@
return nil
}
-func (d *Decoder) reset() error {
+func (d *ZDecoder) reset() error {
return nil
}
diff --git a/vom/encoder.go b/vom/encoder.go
index 16e1419..fa3afcf 100644
--- a/vom/encoder.go
+++ b/vom/encoder.go
@@ -53,9 +53,9 @@
_ vdl.FieldsTarget = (*encoder)(nil)
)
-// Encoder manages the transmission and marshaling of typed values to the other
+// ZEncoder manages the transmission and marshaling of typed values to the other
// side of a connection.
-type Encoder struct {
+type ZEncoder struct {
// The underlying implementation is hidden to avoid exposing the Target
// interface methods.
enc encoder
@@ -90,34 +90,34 @@
anyStartRef *anyStartRef // only non-nil for any
}
-// NewEncoder returns a new Encoder that writes to the given writer in the
+// NewZEncoder returns a new Encoder that writes to the given writer in the
// binary format. The binary format is compact and fast.
-func NewEncoder(w io.Writer) *Encoder {
- return NewVersionedEncoder(DefaultVersion, w)
+func NewZEncoder(w io.Writer) *ZEncoder {
+ return NewVersionedZEncoder(DefaultVersion, w)
}
-// NewVersionedEncoder returns a new Encoder that writes to the given writer with
+// NewVersionedZEncoder returns a new Encoder that writes to the given writer with
// the specified VOM version.
-func NewVersionedEncoder(version Version, w io.Writer) *Encoder {
- typeEnc := newTypeEncoderInternal(version, newXEncoderForTypes(version, w))
- return NewVersionedEncoderWithTypeEncoder(version, w, typeEnc)
+func NewVersionedZEncoder(version Version, w io.Writer) *ZEncoder {
+ typeEnc := newTypeEncoderInternal(version, newEncoderForTypes(version, w))
+ return NewVersionedZEncoderWithTypeEncoder(version, w, typeEnc)
}
-// NewEncoderWithTypeEncoder returns a new Encoder that writes to the given
+// NewZEncoderWithTypeEncoder returns a new ZEncoder that writes to the given
// writer in the binary format. Types will be encoded separately through the
// given typeEncoder.
-func NewEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *Encoder {
- return NewVersionedEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
+func NewZEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *ZEncoder {
+ return NewVersionedZEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
}
-// NewVersionedEncoderWithTypeEncoder returns a new Encoder that writes to the given
+// NewVersionedZEncoderWithTypeEncoder returns a new ZEncoder that writes to the given
// writer in the binary format. Types will be encoded separately through the
// given typeEncoder.
-func NewVersionedEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *Encoder {
+func NewVersionedZEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *ZEncoder {
if !isAllowedVersion(version) {
panic(fmt.Sprintf("unsupported VOM version: %x", version))
}
- return &Encoder{encoder{
+ return &ZEncoder{encoder{
writer: w,
buf: newEncbuf(),
typeStack: make([]typeStackEntry, 0, 10),
@@ -140,7 +140,7 @@
//
// Encode(nil) is a special case that encodes the zero value of the any type.
// See the discussion of zero values in the Value documentation.
-func (e *Encoder) Encode(v interface{}) error {
+func (e *ZEncoder) Encode(v interface{}) error {
if e.enc.version == Version80 {
return verror.New(errDeprecatedVersionUsed, nil)
}
diff --git a/vom/new_raw_bytes_test.go b/vom/new_raw_bytes_test.go
index 8c17d6e..3631218 100644
--- a/vom/new_raw_bytes_test.go
+++ b/vom/new_raw_bytes_test.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build newvdltests
-
package vom_test
import (
@@ -23,7 +21,7 @@
// Interleaved
rb := vom.RawBytes{}
interleavedReader := bytes.NewReader(test.Bytes())
- if err := vom.NewXDecoder(interleavedReader).Decode(&rb); err != nil {
+ if err := vom.NewDecoder(interleavedReader).Decode(&rb); err != nil {
t.Errorf("%s: decode failed: %v", test.Name(), err)
continue
}
@@ -33,7 +31,7 @@
}
var out bytes.Buffer
- enc := vom.NewVersionedXEncoder(test.Version, &out)
+ enc := vom.NewVersionedEncoder(test.Version, &out)
if err := enc.Encode(&rb); err != nil {
t.Errorf("%s: encode failed: %v\nRawBytes: %v", test.Name(), err, rb)
continue
@@ -49,7 +47,7 @@
typeDec.Start()
defer typeDec.Stop()
valueReader := bytes.NewReader(test.ValueBytes())
- if err := vom.NewXDecoderWithTypeDecoder(valueReader, typeDec).Decode(&rb); err != nil {
+ if err := vom.NewDecoderWithTypeDecoder(valueReader, typeDec).Decode(&rb); err != nil {
t.Errorf("%s: decode failed: %v", test.Name(), err)
continue
}
@@ -65,7 +63,7 @@
out.Reset()
var typeOut bytes.Buffer
typeEnc := vom.NewVersionedTypeEncoder(test.Version, &typeOut)
- enc = vom.NewVersionedXEncoderWithTypeEncoder(test.Version, &out, typeEnc)
+ enc = vom.NewVersionedEncoderWithTypeEncoder(test.Version, &out, typeEnc)
if err := enc.Encode(&rb); err != nil {
t.Errorf("%s: encode failed: %v\nRawBytes: %v", test.Name(), err, rb)
continue
@@ -123,7 +121,7 @@
func TestXRawBytesWriter(t *testing.T) {
for _, test := range vomtest.AllPass() {
var buf bytes.Buffer
- enc := vom.NewXEncoder(&buf)
+ enc := vom.NewEncoder(&buf)
rb, err := vom.XRawBytesFromValue(test.Value.Interface())
if err != nil {
t.Errorf("%s: XRawBytesFromValue failed: %v", test.Name(), err)
diff --git a/vom/new_transcode_test.go b/vom/new_transcode_test.go
index 2be0494..9c00e7d 100644
--- a/vom/new_transcode_test.go
+++ b/vom/new_transcode_test.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build newvdltests
-
package vom_test
import (
@@ -18,8 +16,8 @@
func TestTranscodeXDecoderToXEncoder(t *testing.T) {
for _, test := range vomtest.AllPass() {
var buf bytes.Buffer
- enc := vom.NewVersionedXEncoder(test.Version, &buf)
- dec := vom.NewXDecoder(bytes.NewReader(test.Bytes()))
+ enc := vom.NewVersionedEncoder(test.Version, &buf)
+ dec := vom.NewDecoder(bytes.NewReader(test.Bytes()))
if err := vdl.Transcode(enc.Encoder(), dec.Decoder()); err != nil {
t.Errorf("%s: Transcode failed: %v", test.Name(), err)
continue
@@ -34,7 +32,7 @@
func TestTranscodeVDLValueToXEncoder(t *testing.T) {
for _, test := range vomtest.AllPass() {
var buf bytes.Buffer
- enc := vom.NewXEncoder(&buf)
+ enc := vom.NewEncoder(&buf)
if err := vdl.Write(enc.Encoder(), test.Value.Interface()); err != nil {
t.Errorf("%s: vdl.Write failed: %v", test.Name(), err)
continue
diff --git a/vom/raw_bytes.go b/vom/raw_bytes.go
index 913f928..233eb57 100644
--- a/vom/raw_bytes.go
+++ b/vom/raw_bytes.go
@@ -52,12 +52,12 @@
// TODO(toddw): Remove this function after we've switched to XEncoder and
// XDecoder, and thus it's no longer needed.
func XRawBytesFromValue(value interface{}) (*RawBytes, error) {
- data, err := VersionedXEncode(DefaultVersion, value)
+ data, err := VersionedEncode(DefaultVersion, value)
if err != nil {
return nil, err
}
rb := new(RawBytes)
- if err := XDecode(data, rb); err != nil {
+ if err := Decode(data, rb); err != nil {
return nil, err
}
return rb, nil
@@ -114,11 +114,11 @@
return vdl.FromValue(target, vdl.ZeroValue(vdl.AnyType))
}
var buf bytes.Buffer
- enc := NewVersionedEncoder(rb.Version, &buf)
+ enc := NewVersionedZEncoder(rb.Version, &buf)
if err := enc.enc.encodeRaw(rb); err != nil {
return err
}
- dec := NewDecoder(bytes.NewReader(buf.Bytes()))
+ dec := NewZDecoder(bytes.NewReader(buf.Bytes()))
return dec.decodeToTarget(target)
}
@@ -133,7 +133,7 @@
}
func (rb *RawBytes) Decoder() vdl.Decoder {
- dec := NewDecoder(bytes.NewReader(rb.Data))
+ dec := NewZDecoder(bytes.NewReader(rb.Data))
dec.buf.version = rb.Version
dec.refTypes.tids = make([]TypeId, len(rb.RefTypes))
for i, refType := range rb.RefTypes {
@@ -235,7 +235,7 @@
}
r.buf = bytes.NewBuffer(nil)
- e := NewEncoder(r.buf)
+ e := NewZEncoder(r.buf)
r.enc = &e.enc
if _, err := r.enc.writer.Write([]byte{byte(r.enc.version)}); err != nil {
return err
diff --git a/vom/raw_bytes_test.go b/vom/raw_bytes_test.go
index a8e937f..0bd4016 100644
--- a/vom/raw_bytes_test.go
+++ b/vom/raw_bytes_test.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build !newvdltests
-
package vom
import (
@@ -462,10 +460,10 @@
for _, test := range rawBytesTestCases {
var rb *RawBytes
if err := vdl.Convert(&rb, test.goValue); err != nil {
- t.Errorf("vdl.Convert %#v to RawBytes: %v", test.goValue, err)
+ t.Errorf("%s: Convert failed: %v", test.name, err)
}
- if !reflect.DeepEqual(rb, &test.rawBytes) {
- t.Errorf("vdl.Convert to RawBytes %s: got %v, want %v", test.name, rb, test.rawBytes)
+ if got, want := rb, &test.rawBytes; !reflect.DeepEqual(got, want) {
+ t.Errorf("%s\nGOT %v\nWANT %v", test.name, got, want)
}
}
}
@@ -477,12 +475,13 @@
func TestConvertRawBytesWrapped(t *testing.T) {
for _, test := range rawBytesTestCases {
var any structAny
- if err := vdl.Convert(&any, structAnyInterface{test.goValue}); err != nil {
- t.Errorf("vdl.Convert %#v to RawBytes: %v", structAnyInterface{test.goValue}, err)
+ src := structAnyInterface{test.goValue}
+ if err := vdl.Convert(&any, src); err != nil {
+ t.Errorf("%s: Convert failed: %v", test.name, err)
}
got, want := any, structAny{&test.rawBytes}
if !reflect.DeepEqual(got, want) {
- t.Errorf("vdl.Convert to RawBytes %s: got %v, want %v", test.name, got, want)
+ t.Errorf("%s\nGOT %v\nWANT %v", test.name, got, want)
}
}
}
@@ -647,7 +646,7 @@
}
var buf bytes.Buffer
- enc := NewXEncoder(&buf)
+ enc := NewEncoder(&buf)
if err := RawBytesOf(test.Value).VDLWrite(enc.Encoder()); err != nil {
t.Errorf("%s: error in transcode: %v", test.Name, err)
continue
diff --git a/vom/single_shot.go b/vom/single_shot.go
index 14fb247..5838351 100644
--- a/vom/single_shot.go
+++ b/vom/single_shot.go
@@ -21,10 +21,6 @@
return VersionedEncode(DefaultVersion, v)
}
-func XEncode(v interface{}) ([]byte, error) {
- return VersionedXEncode(DefaultVersion, v)
-}
-
// VersionedEncode performs single-shot encoding to a specific version of VOM
func VersionedEncode(version Version, v interface{}) ([]byte, error) {
var buf bytes.Buffer
@@ -34,14 +30,6 @@
return buf.Bytes(), nil
}
-func VersionedXEncode(version Version, v interface{}) ([]byte, error) {
- var buf bytes.Buffer
- if err := NewVersionedXEncoder(version, &buf).Encode(v); err != nil {
- return nil, err
- }
- return buf.Bytes(), nil
-}
-
// Decode reads the value from the given data, and stores it in value v. The
// semantics of value decoding are described by Decoder.Decode.
//
@@ -75,49 +63,8 @@
}
// Decode the value message.
decoder := &Decoder{
- buf: buf,
- typeDec: typeDec,
- }
- if err := decoder.Decode(v); err != nil {
- return err
- }
- // Populate the typeDecoder cache for future re-use.
- if cacheMiss {
- singleShotTypeDecoderCache.insert(key, typeDec)
- }
- return nil
-}
-
-func XDecode(data []byte, v interface{}) error {
- // The implementation below corresponds (logically) to the following:
- // return NewDecoder(bytes.NewReader(data)).Decode(valptr)
- //
- // However decoding type messages is expensive, so we cache typeDecoders to
- // skip the decoding in the common case.
- key, err := computeTypeDecoderCacheKey(data)
- if err != nil {
- return err
- }
- var buf *decbuf
- typeDec := singleShotTypeDecoderCache.lookup(key)
- cacheMiss := false
- if typeDec == nil {
- // Cache miss; start decoding at the beginning of all type messages with a
- // new TypeDecoder.
- cacheMiss = true
- buf = newDecbufFromBytes(data)
- typeDec = newTypeDecoderInternal(buf)
- } else {
- version := Version(data[0])
- data = data[len(key):] // skip the already-read types
- buf = newDecbufFromBytes(data)
- buf.version = version
- typeDec = newDerivedTypeDecoderInternal(buf, typeDec)
- }
- // Decode the value message.
- decoder := &XDecoder{
xDecoder{
- old: &Decoder{
+ old: &ZDecoder{
buf: buf,
typeDec: typeDec,
},
diff --git a/vom/transcode_test.go b/vom/transcode_test.go
index db81063..a91bafb 100644
--- a/vom/transcode_test.go
+++ b/vom/transcode_test.go
@@ -38,8 +38,8 @@
inBytes := hex2Bin(t, test.Hex)
var buf bytes.Buffer
- enc := NewXEncoder(&buf)
- dec := NewXDecoder(bytes.NewReader(inBytes))
+ enc := NewEncoder(&buf)
+ dec := NewDecoder(bytes.NewReader(inBytes))
if err := vdl.Transcode(enc.Encoder(), dec.Decoder()); err != nil {
t.Errorf("%s: error in transcode: %v", test.Name, err)
continue
@@ -59,7 +59,7 @@
}
var buf bytes.Buffer
- enc := NewXEncoder(&buf)
+ enc := NewEncoder(&buf)
if err := test.Value.VDLWrite(enc.Encoder()); err != nil {
t.Errorf("%s: error in transcode: %v", test.Name, err)
continue
diff --git a/vom/type_decoder.go b/vom/type_decoder.go
index 44e868c..2d1968a 100644
--- a/vom/type_decoder.go
+++ b/vom/type_decoder.go
@@ -52,7 +52,7 @@
td := &TypeDecoder{
idToType: make(map[TypeId]*vdl.Type),
idToWire: make(map[TypeId]wireType),
- dec: &xDecoder{old: &Decoder{buf: buf}},
+ dec: &xDecoder{old: &ZDecoder{buf: buf}},
}
td.buildCond = sync.NewCond(&td.buildMu)
return td
@@ -62,7 +62,7 @@
td := &TypeDecoder{
idToType: orig.idToType,
idToWire: orig.idToWire,
- dec: &xDecoder{old: &Decoder{buf: buf}},
+ dec: &xDecoder{old: &ZDecoder{buf: buf}},
}
td.buildCond = sync.NewCond(&td.buildMu)
return td
diff --git a/vom/type_encoder.go b/vom/type_encoder.go
index 432334c..f1cc801 100644
--- a/vom/type_encoder.go
+++ b/vom/type_encoder.go
@@ -42,7 +42,7 @@
return &TypeEncoder{
typeToId: make(map[*vdl.Type]TypeId),
nextId: WireIdFirstUserType,
- enc: newXEncoderForTypes(version, w),
+ enc: newEncoderForTypes(version, w),
sentVersionByte: false,
}
}
diff --git a/vom/xdecoder.go b/vom/xdecoder.go
index e44851e..494c7cf 100644
--- a/vom/xdecoder.go
+++ b/vom/xdecoder.go
@@ -35,12 +35,12 @@
// Decoder manages the receipt and unmarshalling of typed values from the other
// side of a connection.
-type XDecoder struct {
+type Decoder struct {
dec xDecoder
}
type xDecoder struct {
- old *Decoder
+ old *ZDecoder
stack []decoderStackEntry
ignoreNextStartValue bool
}
@@ -56,36 +56,36 @@
// NewDecoder returns a new Decoder that reads from the given reader. The
// Decoder understands all formats generated by the Encoder.
-func NewXDecoder(r io.Reader) *XDecoder {
- return &XDecoder{xDecoder{
- old: NewDecoder(r),
+func NewDecoder(r io.Reader) *Decoder {
+ return &Decoder{xDecoder{
+ old: NewZDecoder(r),
}}
}
// NewDecoderWithTypeDecoder returns a new Decoder that reads from the given
// reader. Types are decoded separately through the typeDec.
-func NewXDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *XDecoder {
- return &XDecoder{xDecoder{
- old: NewDecoderWithTypeDecoder(r, typeDec),
+func NewDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *Decoder {
+ return &Decoder{xDecoder{
+ old: NewZDecoderWithTypeDecoder(r, typeDec),
}}
}
// Decoder returns d as a vdl.Decoder.
-func (d *XDecoder) Decoder() vdl.Decoder {
+func (d *Decoder) Decoder() vdl.Decoder {
return &d.dec
}
// Decode reads the next value and stores it in value v. The type of v need not
// exactly match the type of the originally encoded value; decoding succeeds as
// long as the values are convertible.
-func (d *XDecoder) Decode(v interface{}) error {
+func (d *Decoder) Decode(v interface{}) error {
return vdl.Read(&d.dec, v)
}
// Ignore ignores the next value from d.
//
// TODO(toddw): Rename to SkipValue.
-func (d *XDecoder) Ignore() error {
+func (d *Decoder) Ignore() error {
return d.dec.old.Ignore()
}
@@ -98,8 +98,8 @@
}
func (d *xDecoder) decodeWireType(wt *wireType) (TypeId, error) {
- // TODO(toddw): Flip useOldDecoder=false to enable XDecoder.
- const useOldDecoder = true
+ // TODO(toddw): Flip useOldDecoder=false to enable Decoder.
+ const useOldDecoder = false
if useOldDecoder {
return d.old.decodeWireType(wt)
}
diff --git a/vom/xdecoder_test.go b/vom/xdecoder_test.go
index 7d3db6b..90fd789 100644
--- a/vom/xdecoder_test.go
+++ b/vom/xdecoder_test.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build newvdltests
-
package vom_test
import (
@@ -80,7 +78,7 @@
name := fmt.Sprintf("%s (%s) %s", pre, mode, test.Name())
rvGot := rvNew()
reader := mode.TestReader(bytes.NewReader(test.Bytes()))
- dec := vom.NewXDecoder(reader)
+ dec := vom.NewDecoder(reader)
if err := dec.Decode(rvGot.Interface()); err != nil {
t.Errorf("%s: Decode failed: %v", name, err)
return
@@ -101,7 +99,7 @@
decT := vom.NewTypeDecoder(readerT)
decT.Start()
reader := mode.TestReader(bytes.NewReader(test.ValueBytes()))
- dec := vom.NewXDecoderWithTypeDecoder(reader, decT)
+ dec := vom.NewDecoderWithTypeDecoder(reader, decT)
err := dec.Decode(rvGot.Interface())
decT.Stop()
if err != nil {
@@ -124,7 +122,7 @@
for i := 0; i < 2; i++ {
name := fmt.Sprintf("%s (single-shot %d) %s", pre, i, test.Name())
rvGot := rvNew()
- if err := vom.XDecode(test.Bytes(), rvGot.Interface()); err != nil {
+ if err := vom.Decode(test.Bytes(), rvGot.Interface()); err != nil {
t.Errorf("%s: Decode failed: %v", name, err)
return
}
diff --git a/vom/xencoder.go b/vom/xencoder.go
index 1817e93..3c05d8f 100644
--- a/vom/xencoder.go
+++ b/vom/xencoder.go
@@ -19,37 +19,37 @@
// Encoder manages the transmission and marshaling of typed values to the other
// side of a connection.
-type XEncoder struct {
+type Encoder struct {
enc xEncoder
}
// NewEncoder returns a new Encoder that writes to the given writer in the VOM
// binary format. The binary format is compact and fast.
-func NewXEncoder(w io.Writer) *XEncoder {
- return NewVersionedXEncoder(DefaultVersion, w)
+func NewEncoder(w io.Writer) *Encoder {
+ return NewVersionedEncoder(DefaultVersion, w)
}
// NewVersionedEncoder returns a new Encoder that writes to the given writer with
// the specified version.
-func NewVersionedXEncoder(version Version, w io.Writer) *XEncoder {
- typeEnc := newTypeEncoderInternal(version, newXEncoderForTypes(version, w))
- return NewVersionedXEncoderWithTypeEncoder(version, w, typeEnc)
+func NewVersionedEncoder(version Version, w io.Writer) *Encoder {
+ typeEnc := newTypeEncoderInternal(version, newEncoderForTypes(version, w))
+ return NewVersionedEncoderWithTypeEncoder(version, w, typeEnc)
}
// NewEncoderWithTypeEncoder returns a new Encoder that writes to the given
// writer, where types are encoded separately through the typeEnc.
-func NewXEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *XEncoder {
- return NewVersionedXEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
+func NewEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *Encoder {
+ return NewVersionedEncoderWithTypeEncoder(DefaultVersion, w, typeEnc)
}
// NewVersionedEncoderWithTypeEncoder returns a new Encoder that writes to the
// given writer with the specified version, where types are encoded separately
// through the typeEnc.
-func NewVersionedXEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *XEncoder {
+func NewVersionedEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *Encoder {
if !isAllowedVersion(version) {
panic(fmt.Sprintf("unsupported VOM version: %x", version))
}
- return &XEncoder{xEncoder{
+ return &Encoder{xEncoder{
writer: w,
buf: newEncbuf(),
typeEnc: typeEnc,
@@ -58,10 +58,10 @@
}}
}
-// TODO(toddw): Flip useOldEncoderForTypes=false to enable XEncoder for types.
-const useOldEncoderForTypes = true
+// TODO(toddw): Flip useOldEncoderForTypes=false to enable Encoder for types.
+const useOldEncoderForTypes = false
-func newXEncoderForTypes(version Version, w io.Writer) *xEncoder {
+func newEncoderForTypes(version Version, w io.Writer) *xEncoder {
if !isAllowedVersion(version) {
panic(fmt.Sprintf("unsupported VOM version: %x", version))
}
@@ -106,13 +106,13 @@
}
// Encoder returns e as a vdl.Encoder.
-func (e *XEncoder) Encoder() vdl.Encoder {
+func (e *Encoder) Encoder() vdl.Encoder {
return &e.enc
}
// Encode transmits the value v. Values of type T are encodable as long as the
// T is a valid vdl type.
-func (e *XEncoder) Encode(v interface{}) error {
+func (e *Encoder) Encode(v interface{}) error {
return vdl.Write(&e.enc, v)
}
diff --git a/vom/xencoder_test.go b/vom/xencoder_test.go
index 79940a5..2b9d013 100644
--- a/vom/xencoder_test.go
+++ b/vom/xencoder_test.go
@@ -2,8 +2,6 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// +build newvdltests
-
package vom_test
import (
@@ -33,7 +31,7 @@
{
var buf bytes.Buffer
name := fmt.Sprintf("%s %s", pre, test.Name())
- enc := vom.NewVersionedXEncoder(test.Version, &buf)
+ enc := vom.NewVersionedEncoder(test.Version, &buf)
if err := enc.Encode(value); err != nil {
t.Errorf("%s: Encode failed: %v", name, err)
return
@@ -48,7 +46,7 @@
var buf, bufT bytes.Buffer
name := fmt.Sprintf("%s (with TypeEncoder) %s", pre, test.Name())
encT := vom.NewVersionedTypeEncoder(test.Version, &bufT)
- enc := vom.NewVersionedXEncoderWithTypeEncoder(test.Version, &buf, encT)
+ enc := vom.NewVersionedEncoderWithTypeEncoder(test.Version, &buf, encT)
if err := enc.Encode(value); err != nil {
t.Errorf("%s: Encode failed: %v", name, err)
return
@@ -65,7 +63,7 @@
// Test single-shot vom.XEncode.
{
name := fmt.Sprintf("%s (single-shot) %s", pre, test.Name())
- buf, err := vom.VersionedXEncode(test.Version, value)
+ buf, err := vom.VersionedEncode(test.Version, value)
if err != nil {
t.Errorf("%s: Encode failed: %v", name, err)
return
