func (v value) Format(f fmt.State, c rune) { if debug || f.Flag('#') { fmt.Fprintf(f, "%s["+v.format+"]", typeName(v.v), v.v) } else { fmt.Fprintf(f, v.format, v.v) } }
// Format satisfies the fmt.Formatter interface. func (f formatter) Format(fs fmt.State, c rune) { if c == 'v' && fs.Flag('#') { fmt.Fprintf(fs, "%#v", f.matrix) return } format(f.matrix, f.prefix, f.margin, f.dot, f.squeeze, fs, c) }
// Format is a support routine for fmt.Formatter. It accepts // the formats 'b' (binary), 'o' (octal), 'd' (decimal), 'x' // (lowercase hexadecimal), and 'X' (uppercase hexadecimal). // func (x *Int) Format(s fmt.State, ch int) { cs := charset(ch) // special cases switch { case cs == "": // unknown format fmt.Fprintf(s, "%%!%c(big.Int=%s)", ch, x.String()) return case x == nil: fmt.Fprint(s, "<nil>") return } // determine format format := "%s" if s.Flag('#') { switch ch { case 'o': format = "0%s" case 'x': format = "0x%s" case 'X': format = "0X%s" } } if x.neg { format = "-" + format } fmt.Fprintf(s, format, x.abs.string(cs)) }
func (fo formatter) Format(f fmt.State, c rune) { if c == 'v' && f.Flag('#') && f.Flag(' ') { fo.format(f) return } fo.passThrough(f, c) }
// Format formats the frame according to the fmt.Formatter interface. // // %s source file // %d source line // %n function name // %v equivalent to %s:%d // // Format accepts flags that alter the printing of some verbs, as follows: // // %+s path of source file relative to the compile time GOPATH // %+v equivalent to %+s:%d func (f Frame) Format(s fmt.State, verb rune) { switch verb { case 's': switch { case s.Flag('+'): pc := f.pc() fn := runtime.FuncForPC(pc) if fn == nil { io.WriteString(s, "unknown") } else { file, _ := fn.FileLine(pc) fmt.Fprintf(s, "%s\n\t%s", fn.Name(), file) } default: io.WriteString(s, path.Base(f.file())) } case 'd': fmt.Fprintf(s, "%d", f.line()) case 'n': name := runtime.FuncForPC(f.pc()).Name() io.WriteString(s, funcname(name)) case 'v': f.Format(s, 's') io.WriteString(s, ":") f.Format(s, 'd') } }
func (m fm) Format(fs fmt.State, c rune) { if c == 'v' && fs.Flag('#') { fmt.Fprintf(fs, "%#v", m.Matrix) return } Format(m.Matrix, m.margin, '.', fs, c) }
// Format implements fmt.Formatter. It accepts format.State for // language-specific rendering. func (v Value) Format(s fmt.State, verb rune) { var lang int if state, ok := s.(format.State); ok { lang, _ = language.CompactIndex(state.Language()) } // Get the options. Use DefaultFormat if not present. opt := v.format if opt == nil { opt = defaultFormat } cur := v.currency if cur.index == 0 { cur = opt.currency } // TODO: use pattern. io.WriteString(s, opt.symbol(lang, cur)) if v.amount != nil { s.Write(space) // TODO: apply currency-specific rounding scale, _ := opt.kind.Rounding(cur) if _, ok := s.Precision(); !ok { fmt.Fprintf(s, "%.*f", scale, v.amount) } else { fmt.Fprint(s, v.amount) } } }
// TODO: Implement left/right align func (b ByteSize) Format(f fmt.State, c rune) { var decimal bool switch c { case 'd': decimal = true case 'b': decimal = false case 'v': fmt.Fprintf(f, "%s", b.String()) return default: fmt.Fprintf(f, "%%!%c(ByteSize=%s)", c, b.String()) return } unit, divisor := b.UnitDivisor(decimal) fmtstring := "%" if w, ok := f.Width(); ok { fmtstring += fmt.Sprintf("%d", w-len(unit)-1) } if p, ok := f.Precision(); ok { fmtstring += fmt.Sprintf(".%d", p) } fmtstring += "f %s" fmt.Fprintf(f, fmtstring, float64(b)/float64(divisor), unit) }
// write count copies of text to s func writeMultiple(s fmt.State, text string, count int) { if len(text) > 0 { b := []byte(text) for ; count > 0; count-- { s.Write(b) } } }
func (a Attributes) Format(fs fmt.State, c rune) { for i, tv := range a { fmt.Fprintf(fs, "%s %s", tv.Tag, tv.Value) if i < len(a)-1 { fs.Write([]byte("; ")) } } }
func format(b Bed, fs fmt.State, c rune) { bv := reflect.ValueOf(b) if bv.IsNil() { fmt.Fprint(fs, "<nil>") return } bv = bv.Elem() switch c { case 'v': if fs.Flag('#') { fmt.Fprintf(fs, "&%#v", bv.Interface()) return } fallthrough case 's': width, _ := fs.Width() if !b.canBed(width) { fmt.Fprintf(fs, "%%!(BADWIDTH)%T", b) return } if width == 0 { width = bv.NumField() } for i := 0; i < width; i++ { f := bv.Field(i).Interface() if i >= rgbField { switch i { case rgbField: rv := reflect.ValueOf(f) if reflect.DeepEqual(rv.Interface(), color.RGBA{}) { fs.Write([]byte{'0'}) } else { fmt.Fprintf(fs, "%d,%d,%d", rv.Field(0).Interface(), rv.Field(1).Interface(), rv.Field(2).Interface()) } case blockCountField: fmt.Fprint(fs, f) case blockSizesField, blockStartsField: av := reflect.ValueOf(f) l := av.Len() for j := 0; j < l; j++ { fmt.Fprint(fs, av.Index(j).Interface()) if j < l-1 { fs.Write([]byte{','}) } } } } else { fmt.Fprint(fs, f) } if i < width-1 { fs.Write([]byte{'\t'}) } } default: fmt.Fprintf(fs, "%%!%c(%T=%3s)", c, b, b) } }
// Format implements the fmt.Formatter interface. func (v val) Format(s fmt.State, c rune) { if c == 'v' || c == 's' { fprint(s, reflect.ValueOf(v.v), state{ defaults: s.Flag('+') || s.Flag('#'), }) } else { fmt.Fprintf(s, "%%!%c(pretty.Val)", c) } }
func (fo formatter) Format(f fmt.State, c rune) { if fo.force || c == 'v' && f.Flag('#') && f.Flag(' ') { w := tabwriter.NewWriter(f, 4, 4, 1, ' ', 0) p := &printer{tw: w, Writer: w, visited: make(map[visit]int)} p.printValue(reflect.ValueOf(fo.x), true, fo.quote) w.Flush() return } fo.passThrough(f, c) }
func (e _error) Format(s fmt.State, verb rune) { switch verb { case 'v': if s.Flag('+') { fmt.Fprintf(s, "%+v: ", e.Stacktrace()[0]) } fallthrough case 's': io.WriteString(s, e.msg) } }
func (s *stack) Format(st fmt.State, verb rune) { switch verb { case 'v': switch { case st.Flag('+'): for _, pc := range *s { f := Frame(pc) fmt.Fprintf(st, "\n%+v", f) } } } }
func (f *fundamental) Format(s fmt.State, verb rune) { switch verb { case 'v': if s.Flag('+') { io.WriteString(s, f.msg) f.stack.Format(s, verb) return } fallthrough case 's', 'q': io.WriteString(s, f.msg) } }
func (w wrapper) Format(s fmt.State, verb rune) { switch verb { case 'v': if s.Flag('+') { fmt.Fprintf(s, "%+v\n", w.Cause()) fmt.Fprintf(s, "%+v: %s", w.Stacktrace()[0], w.msg) return } fallthrough case 's': io.WriteString(s, w.Error()) } }
func (w *withMessage) Format(s fmt.State, verb rune) { switch verb { case 'v': if s.Flag('+') { fmt.Fprintf(s, "%+v\n", w.Cause()) io.WriteString(s, w.msg) return } fallthrough case 's', 'q': io.WriteString(s, w.Error()) } }
func (af *ansiFormatter) Format(f fmt.State, c rune) { // reconstruct the format string in bf bf := new(bytes.Buffer) bf.WriteByte('%') for _, x := range []byte{'-', '+', '#', ' ', '0'} { if f.Flag(int(x)) { bf.WriteByte(x) } } if w, ok := f.Width(); ok { fmt.Fprint(bf, w) } if p, ok := f.Precision(); ok { fmt.Fprintf(bf, ".%d", p) } bf.WriteRune(c) format := bf.String() if len(af.codes) == 0 { fmt.Fprintf(f, format, af.value) return } fmt.Fprintf(f, "\x1b[%d", af.codes[0]) for _, code := range af.codes[1:] { fmt.Fprintf(f, ";%d", code) } f.Write([]byte{'m'}) fmt.Fprintf(f, format, af.value) fmt.Fprint(f, "\x1b[0m") }
func (w *withStack) Format(s fmt.State, verb rune) { switch verb { case 'v': if s.Flag('+') { fmt.Fprintf(s, "%+v", w.Cause()) w.stack.Format(s, verb) return } fallthrough case 's': io.WriteString(s, w.Error()) case 'q': fmt.Fprintf(s, "%q", w.Error()) } }
func (r Range) Format(f fmt.State, c int) { i := byte(0) for ; i < r.Min; i++ { f.Write([]byte{'X'}) } for ; float64(i)+0.5 < r.Mean; i++ { f.Write([]byte{'x'}) } for ; i < r.Max; i++ { f.Write([]byte{'.'}) } if w, ok := f.Width(); ok { for ; i < byte(w); i++ { f.Write([]byte{' '}) } } }
func (f *formatter) formatStruct(s fmt.State, c rune, val reflect.Value) { f.depth++ if f.verbose { writeType(s, val) writeLeftcurly(s) if f.pretty { writeNewline(s) writeFullIndent(s, f.depth) } } else { writeLeftcurly(s) } typ := val.Type() for i, n := 0, val.NumField(); i < n; i++ { field := typ.Field(i) if i > 0 { f.sep(s) } if f.verbose || f.extra { s.Write([]byte(field.Name)) writeColon(s) } if field.PkgPath == "" { f.format(s, c, val.Field(i)) } else { field := typ.Field(i) var valptr reflect.Value if val.CanAddr() { valptr = val.Addr() } else { valptr = reflect.New(typ) reflect.Indirect(valptr).Set(val) } fieldp := valptr.Pointer() + field.Offset fieldptr := reflect.NewAt(field.Type, unsafe.Pointer(fieldp)) f.format(s, c, reflect.Indirect(fieldptr)) } } f.depth-- if f.verbose && f.pretty { writeComma(s) writeNewline(s) writeFullIndent(s, f.depth) } writeRightcurly(s) }
func (st StackTrace) Format(s fmt.State, verb rune) { switch verb { case 'v': switch { case s.Flag('+'): for _, f := range st { fmt.Fprintf(s, "\n%+v", f) } case s.Flag('#'): fmt.Fprintf(s, "%#v", []Frame(st)) default: fmt.Fprintf(s, "%v", []Frame(st)) } case 's': fmt.Fprintf(s, "%s", []Frame(st)) } }
func (f *formatter) Format(s fmt.State, c rune) { if c != 'v' || (!f.deep && !f.pretty && f.ifaceok && !f.debug) { // default printf newfmt := reconstructFlags(s, c) fmt.Fprintf(s, newfmt, f.v) return } if f.v == nil { writeNilangle(s) return } f.verbose = s.Flag('#') f.extra = s.Flag('+') f.space = s.Flag(' ') f.format(s, c, reflect.ValueOf(f.v)) }
// Format implements fmt.Formatter with support for the following verbs. // // %s source file // %d line number // %n function name // %v equivalent to %s:%d // // It accepts the '+' and '#' flags for most of the verbs as follows. // // %+s path of source file relative to the compile time GOPATH // %#s full path of source file // %+n import path qualified function name // %+v equivalent to %+s:%d // %#v equivalent to %#s:%d func (c Call) Format(s fmt.State, verb rune) { if c.fn == nil { fmt.Fprintf(s, "%%!%c(NOFUNC)", verb) return } switch verb { case 's', 'v': file, line := c.fn.FileLine(c.pc) switch { case s.Flag('#'): // done case s.Flag('+'): file = file[pkgIndex(file, c.fn.Name()):] default: const sep = "/" if i := strings.LastIndex(file, sep); i != -1 { file = file[i+len(sep):] } } io.WriteString(s, file) if verb == 'v' { buf := [7]byte{':'} s.Write(strconv.AppendInt(buf[:1], int64(line), 10)) } case 'd': _, line := c.fn.FileLine(c.pc) buf := [6]byte{} s.Write(strconv.AppendInt(buf[:0], int64(line), 10)) case 'n': name := c.fn.Name() if !s.Flag('+') { const pathSep = "/" if i := strings.LastIndex(name, pathSep); i != -1 { name = name[i+len(pathSep):] } const pkgSep = "." if i := strings.Index(name, pkgSep); i != -1 { name = name[i+len(pkgSep):] } } io.WriteString(s, name) } }
// Format outputs a pretty-printed Bytes. func (t Bytes) Format(out fmt.State, verb rune) { if out.Flag('#') { // use alternate format: base64w s := base64.URLEncoding.EncodeToString([]byte(t)) if verb == 's' && len(string(t)) > ElisionCutoff { fmt.Fprintf(out, "{%s...}", s[:ElisionLength]) } else { fmt.Fprintf(out, "{%s}", s) } } else { // use default format: hex if verb == 's' && len(string(t)) > ElisionCutoff { fmt.Fprintf(out, "[%02x...]", []byte(t)[:ElisionLength]) } else { fmt.Fprintf(out, "[%02x]", []byte(t)) } } }
func (m Mass) Format(fs fmt.State, c rune) { switch c { case 'v': if fs.Flag('#') { fmt.Fprintf(fs, "%T(%v)", m, float64(m)) return } fallthrough case 'e', 'E', 'f', 'F', 'g', 'G': p, pOk := fs.Precision() w, wOk := fs.Width() switch { case pOk && wOk: fmt.Fprintf(fs, "%*.*"+string(c), w, p, float64(m)) case pOk: fmt.Fprintf(fs, "%.*"+string(c), p, float64(m)) case wOk: fmt.Fprintf(fs, "%*"+string(c), w, float64(m)) default: fmt.Fprintf(fs, "%"+string(c), float64(m)) } fmt.Fprint(fs, " kg") default: fmt.Fprintf(fs, "%%!%c(%T=%g kg)", c, m, float64(m)) return } }
// Format is a support routine for fmt.Formatter. It accepts the formats 'v' and 's' // (string), 'a' (fasta) and 'q' (fastq). String, fasta and fastq formats support // truncated output via the verb's precision. Fasta format supports sequence line // specification via the verb's width field. Fastq format supports optional inclusion // of the '+' line descriptor line with the '+' flag. The 'v' verb supports the '#' // flag for Go syntax output. The 's' and 'v' formats support the '-' flag for // omission of the sequence name and in conjunction with this, the ' ' flag for // alignment justification. func (m *Multi) Format(fs fmt.State, c rune) { if m == nil { fmt.Fprint(fs, "<nil>") return } var align bool switch c { case 'v': if fs.Flag('#') { fmt.Fprintf(fs, "&%#v", *m) return } fallthrough case 's': align = fs.Flag(' ') && fs.Flag('-') fallthrough case 'a', 'q': format := formatString(fs, c) for i, r := range m.Seq { if align { fmt.Fprintf(fs, "%s", strings.Repeat(" ", r.Start()-m.Start())) } fmt.Fprintf(fs, format, r) if i < m.Rows()-1 { fmt.Fprintln(fs) } } default: fmt.Fprintf(fs, "%%!%c(*multi.Multi=%.10s)", c, m) } }
// Format makes Unit satisfy the fmt.Formatter interface. The unit is formatted // with dimensions appended. If the power if the dimension is not zero or one, // symbol^power is appended, if the power is one, just the symbol is appended // and if the power is zero, nothing is appended. Dimensions are appended // in order by symbol name with positive powers ahead of negative powers. func (u *Unit) Format(fs fmt.State, c rune) { if u == nil { fmt.Fprint(fs, "<nil>") } switch c { case 'v': if fs.Flag('#') { fmt.Fprintf(fs, "&%#v", *u) return } fallthrough case 'e', 'E', 'f', 'F', 'g', 'G': p, pOk := fs.Precision() w, wOk := fs.Width() switch { case pOk && wOk: fmt.Fprintf(fs, "%*.*"+string(c), w, p, u.value) case pOk: fmt.Fprintf(fs, "%.*"+string(c), p, u.value) case wOk: fmt.Fprintf(fs, "%*"+string(c), w, u.value) default: fmt.Fprintf(fs, "%"+string(c), u.value) } default: fmt.Fprintf(fs, "%%!%c(*Unit=%g)", c, u) return } if u.formatted == "" && len(u.dimensions) > 0 { u.formatted = u.dimensions.String() } fmt.Fprintf(fs, " %s", u.formatted) }
func (e escapable) Format(f fmt.State, c rune) { s := "%" for i := 0; i < 128; i++ { if f.Flag(i) { s += string(i) } } if w, ok := f.Width(); ok { s += fmt.Sprintf("%d", w) } if p, ok := f.Precision(); ok { s += fmt.Sprintf(".%d", p) } // If we have an uppercase format char and a slice, format each slice // element if unicode.IsUpper(c) && reflect.TypeOf(e.x).Kind() == reflect.Slice { s += strings.ToLower(string(c)) v := reflect.ValueOf(e.x) for i := 0; i < v.Len(); i++ { formatted := fmt.Sprintf(s, v.Index(i)) io.WriteString(f, ReadableEscapeArg(formatted)) if i+1 != v.Len() { io.WriteString(f, " ") } } return } s += string(c) formatted := fmt.Sprintf(s, e.x) io.WriteString(f, ReadableEscapeArg(formatted)) }