kubernetes/vendor/github.com/gogo/protobuf/proto/text.go

var newline …

var spaces …

var endBraceNewline …

var backslashN …

var backslashR …

var backslashT …

var backslashDQ …

var backslashBS …

var posInf …

var negInf …

var nan …

type writer …

type textWriter …

func (w *textWriter) WriteString(s string) (n int, err error) { … }

func (w *textWriter) Write(p []byte) (n int, err error) { … }

func (w *textWriter) WriteByte(c byte) error { … }

func (w *textWriter) indent() { … }

func (w *textWriter) unindent() { … }

func writeName(w *textWriter, props *Properties) error { … }

func requiresQuotes(u string) bool { … }

// isAny reports whether sv is a google.protobuf.Any message
func isAny(sv reflect.Value) bool { … }

// writeProto3Any writes an expanded google.protobuf.Any message.
//
// It returns (false, nil) if sv value can't be unmarshaled (e.g. because
// required messages are not linked in).
//
// It returns (true, error) when sv was written in expanded format or an error
// was encountered.
func (tm *TextMarshaler) writeProto3Any(w *textWriter, sv reflect.Value) (bool, error) { … }

func (tm *TextMarshaler) writeStruct(w *textWriter, sv reflect.Value) error { … }

var textMarshalerType …

// writeAny writes an arbitrary field.
func (tm *TextMarshaler) writeAny(w *textWriter, v reflect.Value, props *Properties) error { … }

// equivalent to C's isprint.
func isprint(c byte) bool { … }

// writeString writes a string in the protocol buffer text format.
// It is similar to strconv.Quote except we don't use Go escape sequences,
// we treat the string as a byte sequence, and we use octal escapes.
// These differences are to maintain interoperability with the other
// languages' implementations of the text format.
func writeString(w *textWriter, s string) error { … }

func writeUnknownStruct(w *textWriter, data []byte) (err error) { … }

func writeUnknownInt(w *textWriter, x uint64, err error) error { … }

type int32Slice …

func (s int32Slice) Len() int           { … }

func (s int32Slice) Less(i, j int) bool { … }

func (s int32Slice) Swap(i, j int)      { … }

// writeExtensions writes all the extensions in pv.
// pv is assumed to be a pointer to a protocol message struct that is extendable.
func (tm *TextMarshaler) writeExtensions(w *textWriter, pv reflect.Value) error { … }

func (tm *TextMarshaler) writeExtension(w *textWriter, name string, pb interface{ … }

func (w *textWriter) writeIndent() { … }

type TextMarshaler …

// Marshal writes a given protocol buffer in text format.
// The only errors returned are from w.
func (tm *TextMarshaler) Marshal(w io.Writer, pb Message) error { … }

// Text is the same as Marshal, but returns the string directly.
func (tm *TextMarshaler) Text(pb Message) string { … }

var defaultTextMarshaler …

var compactTextMarshaler …

// MarshalText writes a given protocol buffer in text format.
// The only errors returned are from w.
func MarshalText(w io.Writer, pb Message) error { … }

// MarshalTextString is the same as MarshalText, but returns the string directly.
func MarshalTextString(pb Message) string { … }

// CompactText writes a given protocol buffer in compact text format (one line).
func CompactText(w io.Writer, pb Message) error { … }

// CompactTextString is the same as CompactText, but returns the string directly.
func CompactTextString(pb Message) string { … }