package proto

Import Path
	google.golang.org/grpc/encoding/proto (on go.dev)

Dependency Relation
	imports 4 packages, and imported by one package

Involved Source Files

	   d➜ proto.go
		Package proto defines the protobuf codec. Importing this package will
		register the codec.
Package-Level Type Names (total 2, neither is exported)

	/* sort exporteds by: alphabet | popularity */
	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type cachedProtoBuffer (struct)

		Fields (total 5, in which 1 are exported)
			Buffer proto.Buffer
			/* 4 unexporteds ... *//* 4 unexporteds: */
			Buffer.buf []byte
			Buffer.deterministic bool
			Buffer.idx int
			lastMarshaledSize uint32
		Methods (total 25, all are exported)
			(*T) Bytes() []byte
				Bytes returns the internal buffer.

			(*T) DebugPrint(s string, b []byte)
				DebugPrint dumps the encoded bytes of b with a header and footer including s
				to stdout. This is only intended for debugging.

			(*T) DecodeFixed32() (uint64, error)
				DecodeFixed32 consumes a 32-bit little-endian integer from the buffer.

			(*T) DecodeFixed64() (uint64, error)
				DecodeFixed64 consumes a 64-bit little-endian integer from the buffer.

			(*T) DecodeGroup(m proto.Message) error
				DecodeGroup consumes a message group from the buffer.
				It assumes that the start group marker has already been consumed and
				consumes all bytes until (and including the end group marker).
				It does not reset m before unmarshaling.

			(*T) DecodeMessage(m proto.Message) error
				DecodeMessage consumes a length-prefixed message from the buffer.
				It does not reset m before unmarshaling.

			(*T) DecodeRawBytes(alloc bool) ([]byte, error)
				DecodeRawBytes consumes a length-prefixed raw bytes from the buffer.
				If alloc is specified, it returns a copy the raw bytes
				rather than a sub-slice of the buffer.

			(*T) DecodeStringBytes() (string, error)
				DecodeStringBytes consumes a length-prefixed raw bytes from the buffer.
				It does not validate whether the raw bytes contain valid UTF-8.

			(*T) DecodeVarint() (uint64, error)
				DecodeVarint consumes an encoded unsigned varint from the buffer.

			(*T) DecodeZigzag32() (uint64, error)
				DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer.

			(*T) DecodeZigzag64() (uint64, error)
				DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer.

			(*T) EncodeFixed32(v uint64) error
				EncodeFixed32 appends a 32-bit little-endian integer to the buffer.

			(*T) EncodeFixed64(v uint64) error
				EncodeFixed64 appends a 64-bit little-endian integer to the buffer.

			(*T) EncodeMessage(m proto.Message) error
				EncodeMessage appends a length-prefixed encoded message to the buffer.

			(*T) EncodeRawBytes(v []byte) error
				EncodeRawBytes appends a length-prefixed raw bytes to the buffer.

			(*T) EncodeStringBytes(v string) error
				EncodeStringBytes appends a length-prefixed raw bytes to the buffer.
				It does not validate whether v contains valid UTF-8.

			(*T) EncodeVarint(v uint64) error
				EncodeVarint appends an unsigned varint encoding to the buffer.

			(*T) EncodeZigzag32(v uint64) error
				EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer.

			(*T) EncodeZigzag64(v uint64) error
				EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer.

			(*T) Marshal(m proto.Message) error
				Marshal appends the wire-format encoding of m to the buffer.

			(*T) Reset()
				Reset clears the internal buffer of all written and unread data.

			(*T) SetBuf(buf []byte)
				SetBuf sets buf as the internal buffer,
				where the contents of buf are considered the unread portion of the buffer.

			(*T) SetDeterministic(deterministic bool)
				SetDeterministic specifies whether to use deterministic serialization.

				Deterministic serialization guarantees that for a given binary, equal
				messages will always be serialized to the same bytes. This implies:

				  - Repeated serialization of a message will return the same bytes.
				  - Different processes of the same binary (which may be executing on
				    different machines) will serialize equal messages to the same bytes.

				Note that the deterministic serialization is NOT canonical across
				languages. It is not guaranteed to remain stable over time. It is unstable
				across different builds with schema changes due to unknown fields.
				Users who need canonical serialization (e.g., persistent storage in a
				canonical form, fingerprinting, etc.) should define their own
				canonicalization specification and implement their own serializer rather
				than relying on this API.

				If deterministic serialization is requested, map entries will be sorted
				by keys in lexographical order. This is an implementation detail and
				subject to change.

			(*T) Unmarshal(m proto.Message) error
				Unmarshal parses the wire-format message in the buffer and
				places the decoded results in m.
				It does not reset m before unmarshaling.

			(*T) Unread() []byte
				Unread returns the unread portion of the buffer.

		As Inputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func marshal(v interface{}, cb *cachedProtoBuffer) ([]byte, error)

	 type codec (struct)
		codec is a Codec implementation with protobuf. It is the default codec for gRPC.

		Methods (total 3, all are exported)
			( T) Marshal(v interface{}) ([]byte, error)
			( T) Name() string
			( T) Unmarshal(data []byte, v interface{}) error
		Implements (at least 2, in which 1 are exported)
			 T : google.golang.org/grpc/encoding.Codec
			/* at least one unexported ... *//* at least one unexported: */
			 T : google.golang.org/grpc.baseCodec


Package-Level Functions (total 3, none are exported)

	/* 3 unexporteds ... *//* 3 unexporteds: */
	 func capToMaxInt32(val int) uint32
	 func init()
	 func marshal(v interface{}, cb *cachedProtoBuffer) ([]byte, error)
Package-Level Variables (only one, which is unexported)

	/* one unexported ... *//* one unexported: */
	  var protoBufferPool *sync.Pool
Package-Level Constants (only one, which is exported)

	const Name = "proto"
		Name is the name registered for the proto compressor.

The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.