Documentation

Overview

    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

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func AppendBytes

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

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

      func AppendFixed32

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

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

        func AppendFixed64

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

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

          func AppendGroup

          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

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

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

              func AppendTag

              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

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

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

                  func ConsumeBytes

                  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

                    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

                      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

                        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

                          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

                            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

                              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

                                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

                                  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

                                    func DecodeBool(x uint64) bool

                                      DecodeBool decodes a uint64 as a bool.

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

                                      func DecodeTag

                                      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

                                        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

                                          func EncodeBool(x bool) uint64

                                            EncodeBool encodes a bool as a uint64.

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

                                            func EncodeTag

                                            func EncodeTag(num Number, typ Type) uint64

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

                                              func EncodeZigZag

                                              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

                                                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

                                                  func SizeBytes(n int) int

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

                                                    func SizeFixed32

                                                    func SizeFixed32() int

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

                                                      func SizeFixed64

                                                      func SizeFixed64() int

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

                                                        func SizeGroup

                                                        func SizeGroup(num Number, n int) int

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

                                                          func SizeTag

                                                          func SizeTag(num Number) int

                                                          func SizeVarint

                                                          func SizeVarint(v uint64) int

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

                                                            Types

                                                            type Number

                                                            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

                                                              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

                                                                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
                                                                  )

                                                                  Source Files