kubernetes/vendor/golang.org/x/text/message/print.go

const commaSpaceString

const nilAngleString

const nilParenString

const nilString

const mapString

const percentBangString

const missingString

const badIndexString

const panicString

const extraString

const badWidthString

const badPrecString

const noVerbString

const invReflectString

var printerPool

// newPrinter allocates a new printer struct or grabs a cached one.
func newPrinter(pp *Printer) *printer {}

// free saves used printer structs in printerFree; avoids an allocation per invocation.
func (p *printer) free() {}

type printer

// Language implements "golang.org/x/text/internal/format".State.
func (p *printer) Language() language.Tag {}

func (p *printer) Width() (wid int, ok bool) {}

func (p *printer) Precision() (prec int, ok bool) {}

func (p *printer) Flag(b int) bool {}

// getField gets the i'th field of the struct value.
// If the field is itself is an interface, return a value for
// the thing inside the interface, not the interface itself.
func getField(v reflect.Value, i int) reflect.Value {}

func (p *printer) unknownType(v reflect.Value) {}

func (p *printer) badVerb(verb rune) {}

func (p *printer) fmtBool(v bool, verb rune) {}

// fmt0x64 formats a uint64 in hexadecimal and prefixes it with 0x or
// not, as requested, by temporarily setting the sharp flag.
func (p *printer) fmt0x64(v uint64, leading0x bool) {}

// fmtInteger formats a signed or unsigned integer.
func (p *printer) fmtInteger(v uint64, isSigned bool, verb rune) {}

// fmtFloat formats a float. The default precision for each verb
// is specified as last argument in the call to fmt_float.
func (p *printer) fmtFloat(v float64, size int, verb rune) {}

func (p *printer) setFlags(f *number.Formatter) {}

func (p *printer) updatePadding(f *number.Formatter) {}

func (p *printer) initDecimal(minFrac, maxFrac int) {}

func (p *printer) initScientific(minFrac, maxFrac int) {}

func (p *printer) fmtDecimalInt(v uint64, isSigned bool) {}

func (p *printer) fmtDecimalFloat(v float64, size, prec int) {}

func (p *printer) fmtVariableFloat(v float64, size int) {}

func (p *printer) fmtScientific(v float64, size, prec int) {}

// fmtComplex formats a complex number v with
// r = real(v) and j = imag(v) as (r+ji) using
// fmtFloat for r and j formatting.
func (p *printer) fmtComplex(v complex128, size int, verb rune) {}

func (p *printer) fmtString(v string, verb rune) {}

func (p *printer) fmtBytes(v []byte, verb rune, typeString string) {}

func (p *printer) fmtPointer(value reflect.Value, verb rune) {}

func (p *printer) catchPanic(arg interface{}

func (p *printer) handleMethods(verb rune) (handled bool) {}

func (p *printer) printArg(arg interface{}

// printValue is similar to printArg but starts with a reflect value, not an interface{} value.
// It does not handle 'p' and 'T' verbs because these should have been already handled by printArg.
func (p *printer) printValue(value reflect.Value, verb rune, depth int) {}

func (p *printer) badArgNum(verb rune) {}

func (p *printer) missingArg(verb rune) {}

func (p *printer) doPrintf(fmt string) {}

func (p *printer) doPrint(a []interface{}

// doPrintln is like doPrint but always adds a space between arguments
// and a newline after the last argument.
func (p *printer) doPrintln(a []interface{}