protobuf: google.golang.org/protobuf/encoding/protowire Index | Files

package protowire

import "google.golang.org/protobuf/encoding/protowire"

Package protowire parses and formats the raw wire encoding. See https://developers.google.com/protocol-buffers/docs/encoding.

For marshaling and unmarshaling entire protobuf messages, use the "google.golang.org/protobuf/proto" package instead.

Index

Package Files

wire.go

func AppendBytes Uses

func AppendBytes(b []byte, v []byte) []byte

AppendBytes appends v to b as a length-prefixed bytes value.

func AppendFixed32 Uses

func AppendFixed32(b []byte, v uint32) []byte

AppendFixed32 appends v to b as a little-endian uint32.

func AppendFixed64 Uses

func AppendFixed64(b []byte, v uint64) []byte

AppendFixed64 appends v to b as a little-endian uint64.

func AppendGroup Uses

func AppendGroup(b []byte, num Number, v []byte) []byte

AppendGroup appends v to b as group value, with a trailing end group marker. The value v must not contain the end marker.

func AppendString Uses

func AppendString(b []byte, v string) []byte

AppendString appends v to b as a length-prefixed bytes value.

func AppendTag Uses

func AppendTag(b []byte, num Number, typ Type) []byte

AppendTag encodes num and typ as a varint-encoded tag and appends it to b.

func AppendVarint Uses

func AppendVarint(b []byte, v uint64) []byte

AppendVarint appends v to b as a varint-encoded uint64.

func ConsumeBytes Uses

func ConsumeBytes(b []byte) (v []byte, n int)

ConsumeBytes parses b as a length-prefixed bytes value, reporting its length. This returns a negative length upon an error (see ParseError).

func ConsumeField Uses

func ConsumeField(b []byte) (Number, Type, int)

ConsumeField parses an entire field record (both tag and value) and returns the field number, the wire type, and the total length. This returns a negative length upon an error (see ParseError).

The total length includes the tag header and the end group marker (if the field is a group).

func ConsumeFieldValue Uses

func ConsumeFieldValue(num Number, typ Type, b []byte) (n int)

ConsumeFieldValue parses a field value and returns its length. This assumes that the field Number and wire Type have already been parsed. This returns a negative length upon an error (see ParseError).

When parsing a group, the length includes the end group marker and the end group is verified to match the starting field number.

func ConsumeFixed32 Uses

func ConsumeFixed32(b []byte) (v uint32, n int)

ConsumeFixed32 parses b as a little-endian uint32, reporting its length. This returns a negative length upon an error (see ParseError).

func ConsumeFixed64 Uses

func ConsumeFixed64(b []byte) (v uint64, n int)

ConsumeFixed64 parses b as a little-endian uint64, reporting its length. This returns a negative length upon an error (see ParseError).

func ConsumeGroup Uses

func ConsumeGroup(num Number, b []byte) (v []byte, n int)

ConsumeGroup parses b as a group value until the trailing end group marker, and verifies that the end marker matches the provided num. The value v does not contain the end marker, while the length does contain the end marker. This returns a negative length upon an error (see ParseError).

func ConsumeString Uses

func ConsumeString(b []byte) (v string, n int)

ConsumeString parses b as a length-prefixed bytes value, reporting its length. This returns a negative length upon an error (see ParseError).

func ConsumeTag Uses

func ConsumeTag(b []byte) (Number, Type, int)

ConsumeTag parses b as a varint-encoded tag, reporting its length. This returns a negative length upon an error (see ParseError).

func ConsumeVarint Uses

func ConsumeVarint(b []byte) (v uint64, n int)

ConsumeVarint parses b as a varint-encoded uint64, reporting its length. This returns a negative length upon an error (see ParseError).

func DecodeBool Uses

func DecodeBool(x uint64) bool

DecodeBool decodes a uint64 as a bool.

Input:  {    0,    1,    2, …}
Output: {false, true, true, …}

func DecodeTag Uses

func DecodeTag(x uint64) (Number, Type)

DecodeTag decodes the field Number and wire Type from its unified form. The Number is -1 if the decoded field number overflows int32. Other than overflow, this does not check for field number validity.

func DecodeZigZag Uses

func DecodeZigZag(x uint64) int64

DecodeZigZag decodes a zig-zag-encoded uint64 as an int64.

Input:  {…,  5,  3,  1,  0,  2,  4,  6, …}
Output: {…, -3, -2, -1,  0, +1, +2, +3, …}

func EncodeBool Uses

func EncodeBool(x bool) uint64

EncodeBool encodes a bool as a uint64.

Input:  {false, true}
Output: {    0,    1}

func EncodeTag Uses

func EncodeTag(num Number, typ Type) uint64

EncodeTag encodes the field Number and wire Type into its unified form.

func EncodeZigZag Uses

func EncodeZigZag(x int64) uint64

EncodeZigZag encodes an int64 as a zig-zag-encoded uint64.

Input:  {…, -3, -2, -1,  0, +1, +2, +3, …}
Output: {…,  5,  3,  1,  0,  2,  4,  6, …}

func ParseError Uses

func ParseError(n int) error

ParseError converts an error code into an error value. This returns nil if n is a non-negative number.

func SizeBytes Uses

func SizeBytes(n int) int

SizeBytes returns the encoded size of a length-prefixed bytes value, given only the length.

func SizeFixed32 Uses

func SizeFixed32() int

SizeFixed32 returns the encoded size of a fixed32; which is always 4.

func SizeFixed64 Uses

func SizeFixed64() int

SizeFixed64 returns the encoded size of a fixed64; which is always 8.

func SizeGroup Uses

func SizeGroup(num Number, n int) int

SizeGroup returns the encoded size of a group, given only the length.

func SizeTag Uses

func SizeTag(num Number) int

func SizeVarint Uses

func SizeVarint(v uint64) int

SizeVarint returns the encoded size of a varint. The size is guaranteed to be within 1 and 10, inclusive.

type Number Uses

type Number int32

Number represents the field number.

const (
    MinValidNumber      Number = 1
    FirstReservedNumber Number = 19000
    LastReservedNumber  Number = 19999
    MaxValidNumber      Number = 1<<29 - 1
)

func (Number) IsValid Uses

func (n Number) IsValid() bool

IsValid reports whether the field number is semantically valid.

Note that while numbers within the reserved range are semantically invalid, they are syntactically valid in the wire format. Implementations may treat records with reserved field numbers as unknown.

type Type Uses

type Type int8

Type represents the wire type.

const (
    VarintType     Type = 0
    Fixed32Type    Type = 5
    Fixed64Type    Type = 1
    BytesType      Type = 2
    StartGroupType Type = 3
    EndGroupType   Type = 4
)

Package protowire imports 4 packages (graph) and is imported by 37 packages. Updated 2020-10-17. Refresh now. Tools for package owners.