const WireVarint … const WireFixed32 … const WireFixed64 … const WireBytes … const WireStartGroup … const WireEndGroup … // EncodeVarint returns the varint encoded bytes of v. func EncodeVarint(v uint64) []byte { … } // SizeVarint returns the length of the varint encoded bytes of v. // This is equal to len(EncodeVarint(v)). func SizeVarint(v uint64) int { … } // DecodeVarint parses a varint encoded integer from b, // returning the integer value and the length of the varint. // It returns (0, 0) if there is a parse error. func DecodeVarint(b []byte) (uint64, int) { … } type Buffer … // NewBuffer allocates a new Buffer initialized with buf, // where the contents of buf are considered the unread portion of the buffer. func NewBuffer(buf []byte) *Buffer { … } // 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. func (b *Buffer) SetDeterministic(deterministic bool) { … } // SetBuf sets buf as the internal buffer, // where the contents of buf are considered the unread portion of the buffer. func (b *Buffer) SetBuf(buf []byte) { … } // Reset clears the internal buffer of all written and unread data. func (b *Buffer) Reset() { … } // Bytes returns the internal buffer. func (b *Buffer) Bytes() []byte { … } // Unread returns the unread portion of the buffer. func (b *Buffer) Unread() []byte { … } // Marshal appends the wire-format encoding of m to the buffer. func (b *Buffer) Marshal(m 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. func (b *Buffer) Unmarshal(m Message) error { … } type unknownFields … func (m *unknownFields) String() string { … } func (m *unknownFields) Reset() { … } func (m *unknownFields) ProtoMessage() { … } // DebugPrint dumps the encoded bytes of b with a header and footer including s // to stdout. This is only intended for debugging. func (*Buffer) DebugPrint(s string, b []byte) { … } // EncodeVarint appends an unsigned varint encoding to the buffer. func (b *Buffer) EncodeVarint(v uint64) error { … } // EncodeZigzag32 appends a 32-bit zig-zag varint encoding to the buffer. func (b *Buffer) EncodeZigzag32(v uint64) error { … } // EncodeZigzag64 appends a 64-bit zig-zag varint encoding to the buffer. func (b *Buffer) EncodeZigzag64(v uint64) error { … } // EncodeFixed32 appends a 32-bit little-endian integer to the buffer. func (b *Buffer) EncodeFixed32(v uint64) error { … } // EncodeFixed64 appends a 64-bit little-endian integer to the buffer. func (b *Buffer) EncodeFixed64(v uint64) error { … } // EncodeRawBytes appends a length-prefixed raw bytes to the buffer. func (b *Buffer) EncodeRawBytes(v []byte) error { … } // EncodeStringBytes appends a length-prefixed raw bytes to the buffer. // It does not validate whether v contains valid UTF-8. func (b *Buffer) EncodeStringBytes(v string) error { … } // EncodeMessage appends a length-prefixed encoded message to the buffer. func (b *Buffer) EncodeMessage(m Message) error { … } // DecodeVarint consumes an encoded unsigned varint from the buffer. func (b *Buffer) DecodeVarint() (uint64, error) { … } // DecodeZigzag32 consumes an encoded 32-bit zig-zag varint from the buffer. func (b *Buffer) DecodeZigzag32() (uint64, error) { … } // DecodeZigzag64 consumes an encoded 64-bit zig-zag varint from the buffer. func (b *Buffer) DecodeZigzag64() (uint64, error) { … } // DecodeFixed32 consumes a 32-bit little-endian integer from the buffer. func (b *Buffer) DecodeFixed32() (uint64, error) { … } // DecodeFixed64 consumes a 64-bit little-endian integer from the buffer. func (b *Buffer) DecodeFixed64() (uint64, 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. func (b *Buffer) DecodeRawBytes(alloc bool) ([]byte, error) { … } // DecodeStringBytes consumes a length-prefixed raw bytes from the buffer. // It does not validate whether the raw bytes contain valid UTF-8. func (b *Buffer) DecodeStringBytes() (string, error) { … } // DecodeMessage consumes a length-prefixed message from the buffer. // It does not reset m before unmarshaling. func (b *Buffer) DecodeMessage(m 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. func (b *Buffer) DecodeGroup(m Message) error { … } // consumeGroup parses b until it finds an end group marker, returning // the raw bytes of the message (excluding the end group marker) and the // the total length of the message (including the end group marker). func consumeGroup(b []byte) ([]byte, int, error) { … }
Codebase Browser
kubernetes