v.io: v.io/v23/vom Index | Examples | Files | Directories

package vom

import "v.io/v23/vom"

Package vom implements the Vanadium Object Marshaling serialization format.

Concept: https://vanadium.github.io/concepts/rpc.html#vom
Specification: https://vanadium.github.io/designdocs/vom-spec.html

VOM supports serialization of all types representable by v.io/v23/vdl, and is a self-describing format that retains full type information. It is the underlying serialization format used by v.io/v23/rpc.

The API is almost identical to encoding/gob. To marshal objects create an Encoder and present it with a series of values. To unmarshal objects create a Decoder and retrieve values. The implementation creates a stream of messages between the Encoder and Decoder.

nolint:golint

Index

Examples

Package Files

binary_util.go buf.go decoder.go decoder_fast_next.go decoder_fast_read.go decoder_util.go doc.go dump.go encoder.go encoder_fast.go init.go misc.go raw_bytes.go single_shot.go splice.go type.go type_decoder.go type_encoder.go vom.vdl.go

Constants

const DefaultVersion = Version(129)
const Version80 = Version(128)
const Version81 = Version(129)
const WireCtrlEnd = byte(225) // End of struct or union
const WireCtrlNil = byte(224) // Nil in optional or any
const WireCtrlTypeIncomplete = byte(226) // Marks that the type message is incomplete until future messages are received
const WireIdAny = TypeId(15)
const WireIdBool = TypeId(1)

Primitive types.

const WireIdByte = TypeId(2)
const WireIdByteList = TypeId(39)

Other commonly used composites.

const WireIdFirstUserType = TypeId(41)

The first user-defined TypeId is 41.

const WireIdFloat32 = TypeId(10)
const WireIdFloat64 = TypeId(11)
const WireIdInt16 = TypeId(7)
const WireIdInt32 = TypeId(8)
const WireIdInt64 = TypeId(9)
const WireIdInt8 = TypeId(16)
const WireIdString = TypeId(3)
const WireIdStringList = TypeId(40)
const WireIdTypeObject = TypeId(14)

Wire ids 12 and 13 were previously used for complex64 and complex 128.

const WireIdUint16 = TypeId(4)
const WireIdUint32 = TypeId(5)
const WireIdUint64 = TypeId(6)

Variables

var ControlKindAll = [...]ControlKind{ControlKindNil, ControlKindEnd, ControlKindIncompleteType}

ControlKindAll holds all labels for ControlKind.

var DumpKindAll = [...]DumpKind{DumpKindVersion, DumpKindControl, DumpKindMsgId, DumpKindTypeMsg, DumpKindValueMsg, DumpKindMsgLen, DumpKindAnyMsgLen, DumpKindAnyLensLen, DumpKindTypeIdsLen, DumpKindTypeId, DumpKindPrimValue, DumpKindByteLen, DumpKindValueLen, DumpKindIndex, DumpKindWireTypeIndex}

DumpKindAll holds all labels for DumpKind.

func Decode Uses

func Decode(data []byte, v interface{}) error

Decode reads the value from the given data, and stores it in value v. The semantics of value decoding are described by Decoder.Decode.

This is a "single-shot" decoding; the data must have been encoded by a call to vom.Encode.

func Dump Uses

func Dump(data []byte) (string, error)

Dump returns a human-readable dump of the given vom data, in the default string format.

func Encode Uses

func Encode(v interface{}) ([]byte, error)

Encode writes the value v and returns the encoded bytes. The semantics of value encoding are described by Encoder.Encode.

This is a "single-shot" encoding; full type information is always included in the returned encoding, as if a new encoder were used for each call.

func VDLReadPrimitive Uses

func VDLReadPrimitive(dec vdl.Decoder, x *Primitive) error

func VersionedEncode Uses

func VersionedEncode(version Version, v interface{}) ([]byte, error)

VersionedEncode performs single-shot encoding to a specific version of VOM

type ControlKind Uses

type ControlKind int

ControlKind enumerates the different kinds of control bytes.

const (
    ControlKindNil ControlKind = iota
    ControlKindEnd
    ControlKindIncompleteType
)

func ControlKindFromString Uses

func ControlKindFromString(label string) (x ControlKind, err error)

ControlKindFromString creates a ControlKind from a string label. nolint:deadcode,unused

func (*ControlKind) Set Uses

func (x *ControlKind) Set(label string) error

Set assigns label to x.

func (ControlKind) String Uses

func (x ControlKind) String() string

String returns the string label of x.

func (ControlKind) VDLIsZero Uses

func (x ControlKind) VDLIsZero() bool

func (*ControlKind) VDLRead Uses

func (x *ControlKind) VDLRead(dec vdl.Decoder) error

func (ControlKind) VDLReflect Uses

func (ControlKind) VDLReflect(struct {
    Name string `vdl:"v.io/v23/vom.ControlKind"`
    Enum struct{ Nil, End, IncompleteType string }
})

func (ControlKind) VDLWrite Uses

func (x ControlKind) VDLWrite(enc vdl.Encoder) error

type Decoder Uses

type Decoder struct {
    // contains filtered or unexported fields
}

Decoder manages the receipt and unmarshalling of typed values from the other side of a connection.

func NewDecoder Uses

func NewDecoder(r io.Reader) *Decoder

NewDecoder returns a new Decoder that reads from the given reader. The Decoder understands all formats generated by the Encoder.

func NewDecoderWithTypeDecoder Uses

func NewDecoderWithTypeDecoder(r io.Reader, typeDec *TypeDecoder) *Decoder

NewDecoderWithTypeDecoder returns a new Decoder that reads from the given reader. Types are decoded separately through the typeDec.

func (*Decoder) Decode Uses

func (d *Decoder) Decode(v interface{}) error

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 (*Decoder) Decoder Uses

func (d *Decoder) Decoder() vdl.Decoder

Decoder returns d as a vdl.Decoder.

type DumpAtom Uses

type DumpAtom struct {
    Kind  DumpKind  // The kind of this atom.
    Bytes []byte    // Raw bytes in the vom encoding representing this atom.
    Data  Primitive // Primitive data corresponding to the raw bytes.
    Debug string    // Free-form debug string with more information.
}

DumpAtom describes a single indivisible piece of the vom encoding. The vom encoding is composed of a stream of these atoms.

func (DumpAtom) String Uses

func (a DumpAtom) String() string

func (DumpAtom) VDLIsZero Uses

func (x DumpAtom) VDLIsZero() bool

func (*DumpAtom) VDLRead Uses

func (x *DumpAtom) VDLRead(dec vdl.Decoder) error

func (DumpAtom) VDLReflect Uses

func (DumpAtom) VDLReflect(struct {
    Name string `vdl:"v.io/v23/vom.DumpAtom"`
})

func (DumpAtom) VDLWrite Uses

func (x DumpAtom) VDLWrite(enc vdl.Encoder) error

type DumpKind Uses

type DumpKind int

DumpKind enumerates the different kinds of dump atoms.

const (
    DumpKindVersion DumpKind = iota
    DumpKindControl
    DumpKindMsgId
    DumpKindTypeMsg
    DumpKindValueMsg
    DumpKindMsgLen
    DumpKindAnyMsgLen
    DumpKindAnyLensLen
    DumpKindTypeIdsLen
    DumpKindTypeId
    DumpKindPrimValue
    DumpKindByteLen
    DumpKindValueLen
    DumpKindIndex
    DumpKindWireTypeIndex
)

func DumpKindFromString Uses

func DumpKindFromString(label string) (x DumpKind, err error)

DumpKindFromString creates a DumpKind from a string label. nolint:deadcode,unused

func (*DumpKind) Set Uses

func (x *DumpKind) Set(label string) error

Set assigns label to x.

func (DumpKind) String Uses

func (x DumpKind) String() string

String returns the string label of x.

func (DumpKind) VDLIsZero Uses

func (x DumpKind) VDLIsZero() bool

func (*DumpKind) VDLRead Uses

func (x *DumpKind) VDLRead(dec vdl.Decoder) error

func (DumpKind) VDLReflect Uses

func (DumpKind) VDLReflect(struct {
    Name string `vdl:"v.io/v23/vom.DumpKind"`
    Enum struct{ Version, Control, MsgId, TypeMsg, ValueMsg, MsgLen, AnyMsgLen, AnyLensLen, TypeIdsLen, TypeId, PrimValue, ByteLen, ValueLen, Index, WireTypeIndex string }
})

func (DumpKind) VDLWrite Uses

func (x DumpKind) VDLWrite(enc vdl.Encoder) error

type DumpStatus Uses

type DumpStatus struct {
    MsgId      int64
    MsgLen     int
    MsgN       int
    Buf        []byte
    Debug      string
    RefTypes   []*vdl.Type
    RefAnyLens []uint64
    Value      *vdl.Value
    Err        error
}

DumpStatus represents the state of the dumper. It is written to the DumpWriter at the end of decoding each value, and may also be triggered explicitly via Dumper.Status calls to get information for partial dumps. nolint:golint // API change required.

func (DumpStatus) String Uses

func (s DumpStatus) String() string

type DumpWriter Uses

type DumpWriter interface {
    // WriteAtom is called by the Dumper for each atom it decodes.
    WriteAtom(atom DumpAtom)
    // WriteStatus is called by the Dumper to indicate the status of the dumper.
    WriteStatus(status DumpStatus)
}

DumpWriter is the interface that describes how to write out dumps produced by the Dumper. Implement this interface to customize dump output behavior.

func NewDumpWriter Uses

func NewDumpWriter(w io.Writer) DumpWriter

NewDumpWriter returns a DumpWriter that outputs dumps to w, writing each atom and status on its own line, in their default string format.

type Dumper Uses

type Dumper struct {
    // contains filtered or unexported fields
}

Dumper produces dumps of vom data. It implements the io.WriteCloser interface; Data is fed to the dumper via Write, and Close must be called at the end of usage to release resources.

Dumps of vom data consist of a single stream of DumpAtom and DumpStatus. Each atom describes a single piece of the vom encoding; the vom encoding is composed of a stream of atoms. The status describes the state of the dumper at that point in the stream.

func NewDumper Uses

func NewDumper(w DumpWriter) *Dumper

NewDumper returns a new Dumper, which writes dumps of vom data to w.

Close must be called on the returned Dumper to release resources.

func (*Dumper) Close Uses

func (d *Dumper) Close() error

Close flushes buffered data and releases resources. Close must be called exactly once, when the dumper is no longer needed.

func (*Dumper) Flush Uses

func (d *Dumper) Flush() error

Flush flushes buffered data, and causes the dumper to restart decoding at the start of a new message. This is useful if the previous data in the stream was corrupt, and subsequent data will be for new vom messages. Previously buffered type information remains intact.

func (*Dumper) Status Uses

func (d *Dumper) Status()

Status triggers an explicit dump of the current status of the dumper to the DumpWriter. Status is normally generated at the end of each each decoded message; call Status to get extra information for partial dumps and errors.

func (*Dumper) Write Uses

func (d *Dumper) Write(data []byte) (int, error)

Write implements the io.Writer interface method. This is the mechanism by which data is fed into the dumper.

type Encoder Uses

type Encoder struct {
    // contains filtered or unexported fields
}

Encoder manages the transmission and marshaling of typed values to the other side of a connection.

func NewEncoder Uses

func NewEncoder(w io.Writer) *Encoder

NewEncoder returns a new Encoder that writes to the given writer in the VOM binary format. The binary format is compact and fast.

func NewEncoderWithTypeEncoder Uses

func NewEncoderWithTypeEncoder(w io.Writer, typeEnc *TypeEncoder) *Encoder

NewEncoderWithTypeEncoder returns a new Encoder that writes to the given writer, where types are encoded separately through the typeEnc.

func NewVersionedEncoder Uses

func NewVersionedEncoder(version Version, w io.Writer) *Encoder

NewVersionedEncoder returns a new Encoder that writes to the given writer with the specified version.

func NewVersionedEncoderWithTypeEncoder Uses

func NewVersionedEncoderWithTypeEncoder(version Version, w io.Writer, typeEnc *TypeEncoder) *Encoder

NewVersionedEncoderWithTypeEncoder returns a new Encoder that writes to the given writer with the specified version, where types are encoded separately through the typeEnc.

func (*Encoder) Encode Uses

func (e *Encoder) Encode(v interface{}) error

Encode transmits the value v. Values of type T are encodable as long as the T is a valid vdl type.

func (*Encoder) Encoder Uses

func (e *Encoder) Encoder() vdl.Encoder

Encoder returns e as a vdl.Encoder.

type ExtractEncodedBytes Uses

type ExtractEncodedBytes struct {
    Data                 []byte
    NumToDecode, Decoded int
}

ExtractEncodedBytes represents an already encoded stream that has been extracted from a separate, independent vom stream. NumToDecode controls how many values are to be read from the existing stream, or 0 to read all values.

nolint:errcheck

Code:

abuf := &bytes.Buffer{}
encA := vom.NewEncoder(abuf)
encA.Encode("first")
encA.Encode(&m{"stream-a"})
encA.Encode(int64(33))
encA.Encode("last")

var first, last string
var vm m
var vi int
dec := vom.NewDecoder(abuf)
dec.Decode(&first)
var extractor vom.ExtractEncodedBytes
dec.Decode(&extractor)
edec := vom.NewDecoder(bytes.NewBuffer(extractor.Data))
edec.Decode(&vm)
edec.Decode(&vi)
edec.Decode(&last)
fmt.Println(extractor.Decoded)
fmt.Println(first)
fmt.Println(vm.M)
fmt.Println(vi)
fmt.Println(last)

Output:

3
first
stream-a
33
last

func (*ExtractEncodedBytes) VDLRead Uses

func (eb *ExtractEncodedBytes) VDLRead(dec vdl.Decoder) error

VDLRead implements vdl.Reader.

type MergeEncodedBytes Uses

type MergeEncodedBytes struct {
    Data []byte
}

MergeEncodedBytes represents an already encoded vom stream that is intended for use when merging the output of multiple, independent, vom encoders.

nolint:errcheck

Code:

abuf := &bytes.Buffer{}
encA := vom.NewEncoder(abuf)
encA.Encode(&m{"stream-a"}) //nolint:errcheck

bbuf := &bytes.Buffer{}
encB := vom.NewEncoder(bbuf)
encB.Encode(m{"stream-b"})
encB.Encode(vom.MergeEncodedBytes{Data: abuf.Bytes()})

dec := vom.NewDecoder(bbuf)
va, vb := m{}, m{}
dec.Decode(&vb)
dec.Decode(&va)
fmt.Println(va.M)
fmt.Println(vb.M)

Output:

stream-a
stream-b

func (*MergeEncodedBytes) VDLWrite Uses

func (eb *MergeEncodedBytes) VDLWrite(enc vdl.Encoder) error

VDLWrite implements vdl.Writer. Note that it decodes and re-encodes the vom stream and is consequently expensive.

type Primitive Uses

type Primitive interface {
    // Index returns the field index.
    Index() int
    // Interface returns the field value as an interface.
    Interface() interface{}
    // Name returns the field name.
    Name() string
    // VDLReflect describes the Primitive union type.
    VDLReflect(vdlPrimitiveReflect)
    VDLIsZero() bool
    VDLWrite(vdl.Encoder) error
}

Primitive represents any single field of the Primitive union type.

Primitive represents one of the primitive vom values. All vom values are composed of combinations of these primitives.

type PrimitivePBool Uses

type PrimitivePBool struct{ Value bool }

PrimitivePBool represents field PBool of the Primitive union type.

func (PrimitivePBool) Index Uses

func (x PrimitivePBool) Index() int

func (PrimitivePBool) Interface Uses

func (x PrimitivePBool) Interface() interface{}

func (PrimitivePBool) Name Uses

func (x PrimitivePBool) Name() string

func (PrimitivePBool) VDLIsZero Uses

func (x PrimitivePBool) VDLIsZero() bool

func (PrimitivePBool) VDLReflect Uses

func (x PrimitivePBool) VDLReflect(vdlPrimitiveReflect)

func (PrimitivePBool) VDLWrite Uses

func (x PrimitivePBool) VDLWrite(enc vdl.Encoder) error

type PrimitivePByte Uses

type PrimitivePByte struct{ Value byte }

PrimitivePByte represents field PByte of the Primitive union type.

func (PrimitivePByte) Index Uses

func (x PrimitivePByte) Index() int

func (PrimitivePByte) Interface Uses

func (x PrimitivePByte) Interface() interface{}

func (PrimitivePByte) Name Uses

func (x PrimitivePByte) Name() string

func (PrimitivePByte) VDLIsZero Uses

func (x PrimitivePByte) VDLIsZero() bool

func (PrimitivePByte) VDLReflect Uses

func (x PrimitivePByte) VDLReflect(vdlPrimitiveReflect)

func (PrimitivePByte) VDLWrite Uses

func (x PrimitivePByte) VDLWrite(enc vdl.Encoder) error

type PrimitivePControl Uses

type PrimitivePControl struct{ Value ControlKind }

PrimitivePControl represents field PControl of the Primitive union type.

func (PrimitivePControl) Index Uses

func (x PrimitivePControl) Index() int

func (PrimitivePControl) Interface Uses

func (x PrimitivePControl) Interface() interface{}

func (PrimitivePControl) Name Uses

func (x PrimitivePControl) Name() string

func (PrimitivePControl) VDLIsZero Uses

func (x PrimitivePControl) VDLIsZero() bool

func (PrimitivePControl) VDLReflect Uses

func (x PrimitivePControl) VDLReflect(vdlPrimitiveReflect)

func (PrimitivePControl) VDLWrite Uses

func (x PrimitivePControl) VDLWrite(enc vdl.Encoder) error

type PrimitivePFloat Uses

type PrimitivePFloat struct{ Value float64 }

PrimitivePFloat represents field PFloat of the Primitive union type.

func (PrimitivePFloat) Index Uses

func (x PrimitivePFloat) Index() int

func (PrimitivePFloat) Interface Uses

func (x PrimitivePFloat) Interface() interface{}

func (PrimitivePFloat) Name Uses

func (x PrimitivePFloat) Name() string

func (PrimitivePFloat) VDLIsZero Uses

func (x PrimitivePFloat) VDLIsZero() bool

func (PrimitivePFloat) VDLReflect Uses

func (x PrimitivePFloat) VDLReflect(vdlPrimitiveReflect)

func (PrimitivePFloat) VDLWrite Uses

func (x PrimitivePFloat) VDLWrite(enc vdl.Encoder) error

type PrimitivePInt Uses

type PrimitivePInt struct{ Value int64 }

PrimitivePInt represents field PInt of the Primitive union type.

func (PrimitivePInt) Index Uses

func (x PrimitivePInt) Index() int

func (PrimitivePInt) Interface Uses

func (x PrimitivePInt) Interface() interface{}

func (PrimitivePInt) Name Uses

func (x PrimitivePInt) Name() string

func (PrimitivePInt) VDLIsZero Uses

func (x PrimitivePInt) VDLIsZero() bool

func (PrimitivePInt) VDLReflect Uses

func (x PrimitivePInt) VDLReflect(vdlPrimitiveReflect)

func (PrimitivePInt) VDLWrite Uses

func (x PrimitivePInt) VDLWrite(enc vdl.Encoder) error

type PrimitivePString Uses

type PrimitivePString struct{ Value string }

PrimitivePString represents field PString of the Primitive union type.

func (PrimitivePString) Index Uses

func (x PrimitivePString) Index() int

func (PrimitivePString) Interface Uses

func (x PrimitivePString) Interface() interface{}

func (PrimitivePString) Name Uses

func (x PrimitivePString) Name() string

func (PrimitivePString) VDLIsZero Uses

func (x PrimitivePString) VDLIsZero() bool

func (PrimitivePString) VDLReflect Uses

func (x PrimitivePString) VDLReflect(vdlPrimitiveReflect)

func (PrimitivePString) VDLWrite Uses

func (x PrimitivePString) VDLWrite(enc vdl.Encoder) error

type PrimitivePUint Uses

type PrimitivePUint struct{ Value uint64 }

PrimitivePUint represents field PUint of the Primitive union type.

func (PrimitivePUint) Index Uses

func (x PrimitivePUint) Index() int

func (PrimitivePUint) Interface Uses

func (x PrimitivePUint) Interface() interface{}

func (PrimitivePUint) Name Uses

func (x PrimitivePUint) Name() string

func (PrimitivePUint) VDLIsZero Uses

func (x PrimitivePUint) VDLIsZero() bool

func (PrimitivePUint) VDLReflect Uses

func (x PrimitivePUint) VDLReflect(vdlPrimitiveReflect)

func (PrimitivePUint) VDLWrite Uses

func (x PrimitivePUint) VDLWrite(enc vdl.Encoder) error

type RawBytes Uses

type RawBytes struct {
    Version    Version
    Type       *vdl.Type
    RefTypes   []*vdl.Type
    AnyLengths []int
    Data       []byte
}

func RawBytesFromValue Uses

func RawBytesFromValue(value interface{}) (*RawBytes, error)

func RawBytesOf Uses

func RawBytesOf(value interface{}) *RawBytes

func (*RawBytes) Decoder Uses

func (rb *RawBytes) Decoder() vdl.Decoder

func (*RawBytes) IsNil Uses

func (rb *RawBytes) IsNil() bool

func (*RawBytes) String Uses

func (rb *RawBytes) String() string

String outputs a string representation of RawBytes of the form RawBytes{Version81, int8, RefTypes{bool, string}, AnyLengths{4}, fa0e9dcc}

func (*RawBytes) ToValue Uses

func (rb *RawBytes) ToValue(value interface{}) error

func (*RawBytes) VDLEqual Uses

func (rb *RawBytes) VDLEqual(x interface{}) bool

TODO(toddw) This is slow - we should fix this.

func (*RawBytes) VDLIsZero Uses

func (rb *RawBytes) VDLIsZero() bool

func (*RawBytes) VDLRead Uses

func (rb *RawBytes) VDLRead(dec vdl.Decoder) error

func (RawBytes) VDLReflect Uses

func (RawBytes) VDLReflect(struct {
    Type interface{} // ensure vdl.TypeOf(RawBytes{}) returns vdl.AnyType
})

func (*RawBytes) VDLWrite Uses

func (rb *RawBytes) VDLWrite(enc vdl.Encoder) error

type TypeDecoder Uses

type TypeDecoder struct {
    // contains filtered or unexported fields
}

TypeDecoder manages the receipt and unmarshalling of types from the other side of a connection. Start must be called to start decoding types, and Stop must be called to reclaim resources.

func NewTypeDecoder Uses

func NewTypeDecoder(r io.Reader) *TypeDecoder

NewTypeDecoder returns a new TypeDecoder that reads from the given reader. The TypeDecoder understands all wire type formats generated by the TypeEncoder.

func (*TypeDecoder) Start Uses

func (d *TypeDecoder) Start()

Start must be called to start decoding types.

func (*TypeDecoder) Stop Uses

func (d *TypeDecoder) Stop()

Stop must be called after Start, to stop decoding types and reclaim resources. Once Stop is called, subsequent Decode calls on Decoders initialized with d will return errors.

type TypeEncoder Uses

type TypeEncoder struct {
    // contains filtered or unexported fields
}

TypeEncoder manages the transmission and marshaling of types to the other side of a connection.

func NewTypeEncoder Uses

func NewTypeEncoder(w io.Writer) *TypeEncoder

NewTypeEncoder returns a new TypeEncoder that writes types to the given writer in the binary format.

func NewVersionedTypeEncoder Uses

func NewVersionedTypeEncoder(version Version, w io.Writer) *TypeEncoder

NewTypeEncoderVersion returns a new TypeEncoder that writes types to the given writer in the specified VOM version.

type TypeId Uses

type TypeId uint64

TypeId uniquely identifies a type definition within a vom stream.

func (TypeId) VDLIsZero Uses

func (x TypeId) VDLIsZero() bool

func (*TypeId) VDLRead Uses

func (x *TypeId) VDLRead(dec vdl.Decoder) error

func (TypeId) VDLReflect Uses

func (TypeId) VDLReflect(struct {
    Name string `vdl:"v.io/v23/vom.TypeId"`
})

func (TypeId) VDLWrite Uses

func (x TypeId) VDLWrite(enc vdl.Encoder) error

type Version Uses

type Version byte

Version is the vom version.

func (Version) String Uses

func (v Version) String() string

func (Version) VDLIsZero Uses

func (x Version) VDLIsZero() bool

func (*Version) VDLRead Uses

func (x *Version) VDLRead(dec vdl.Decoder) error

func (Version) VDLReflect Uses

func (Version) VDLReflect(struct {
    Name string `vdl:"v.io/v23/vom.Version"`
})

func (Version) VDLWrite Uses

func (x Version) VDLWrite(enc vdl.Encoder) error

Directories

PathSynopsis
internalnolint:golint
internal/vombenchgen
vomtestPackage vomtest provides protocol conformance tests for the Vanadium Object Marshaller (VOM).

Package vom imports 13 packages (graph) and is imported by 175 packages. Updated 2020-09-28. Refresh now. Tools for package owners.