From 621e49bb465f500cc46d47e39e828cf76d6381d7 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 24 Jul 2018 14:35:44 +0200 Subject: update vendor --- vendor/golang.org/x/text/number/option.go | 177 ++++++++++++++++++++++++++++++ 1 file changed, 177 insertions(+) create mode 100644 vendor/golang.org/x/text/number/option.go (limited to 'vendor/golang.org/x/text/number/option.go') diff --git a/vendor/golang.org/x/text/number/option.go b/vendor/golang.org/x/text/number/option.go new file mode 100644 index 0000000..de96f8e --- /dev/null +++ b/vendor/golang.org/x/text/number/option.go @@ -0,0 +1,177 @@ +// Copyright 2017 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package number + +import ( + "fmt" + + "golang.org/x/text/internal/number" + "golang.org/x/text/language" +) + +// An Option configures a Formatter. +type Option option + +type option func(tag language.Tag, f *number.Formatter) + +// TODO: SpellOut requires support of the ICU RBNF format. +// func SpellOut() Option + +// NoSeparator causes a number to be displayed without grouping separators. +func NoSeparator() Option { + return func(t language.Tag, f *number.Formatter) { + f.GroupingSize = [2]uint8{} + } +} + +// MaxIntegerDigits limits the number of integer digits, eliminating the +// most significant digits. +func MaxIntegerDigits(max int) Option { + return func(t language.Tag, f *number.Formatter) { + if max >= 1<<8 { + max = (1 << 8) - 1 + } + f.MaxIntegerDigits = uint8(max) + } +} + +// MinIntegerDigits specifies the minimum number of integer digits, adding +// leading zeros when needed. +func MinIntegerDigits(min int) Option { + return func(t language.Tag, f *number.Formatter) { + if min >= 1<<8 { + min = (1 << 8) - 1 + } + f.MinIntegerDigits = uint8(min) + } +} + +// MaxFractionDigits specifies the maximum number of fractional digits. +func MaxFractionDigits(max int) Option { + return func(t language.Tag, f *number.Formatter) { + if max >= 1<<15 { + max = (1 << 15) - 1 + } + f.MaxFractionDigits = int16(max) + } +} + +// MinFractionDigits specifies the minimum number of fractional digits. +func MinFractionDigits(min int) Option { + return func(t language.Tag, f *number.Formatter) { + if min >= 1<<8 { + min = (1 << 8) - 1 + } + f.MinFractionDigits = uint8(min) + } +} + +// Precision sets the maximum number of significant digits. A negative value +// means exact. +func Precision(prec int) Option { + return func(t language.Tag, f *number.Formatter) { + f.SetPrecision(prec) + } +} + +// Scale simultaneously sets MinFractionDigits and MaxFractionDigits to the +// given value. +func Scale(decimals int) Option { + return func(t language.Tag, f *number.Formatter) { + f.SetScale(decimals) + } +} + +// IncrementString sets the incremental value to which numbers should be +// rounded. For instance: Increment("0.05") will cause 1.44 to round to 1.45. +// IncrementString also sets scale to the scale of the increment. +func IncrementString(decimal string) Option { + increment := 0 + scale := 0 + d := decimal + p := 0 + for ; p < len(d) && '0' <= d[p] && d[p] <= '9'; p++ { + increment *= 10 + increment += int(d[p]) - '0' + } + if p < len(d) && d[p] == '.' { + for p++; p < len(d) && '0' <= d[p] && d[p] <= '9'; p++ { + increment *= 10 + increment += int(d[p]) - '0' + scale++ + } + } + if p < len(d) { + increment = 0 + scale = 0 + } + return func(t language.Tag, f *number.Formatter) { + f.Increment = uint32(increment) + f.IncrementScale = uint8(scale) + f.SetScale(scale) + } +} + +func noop(language.Tag, *number.Formatter) {} + +// PatternOverrides allows users to specify alternative patterns for specific +// languages. The Pattern will be overridden for all languages in a subgroup as +// well. The function will panic for invalid input. It is best to create this +// option at startup time. +// PatternOverrides must be the first Option passed to a formatter. +func PatternOverrides(patterns map[string]string) Option { + // TODO: make it so that it does not have to be the first option. + // TODO: use -x-nochild to indicate it does not override child tags. + m := map[language.Tag]*number.Pattern{} + for k, v := range patterns { + tag := language.MustParse(k) + p, err := number.ParsePattern(v) + if err != nil { + panic(fmt.Errorf("number: PatternOverrides: %v", err)) + } + m[tag] = p + } + return func(t language.Tag, f *number.Formatter) { + // TODO: Use language grouping relation instead of parent relation. + // TODO: Should parent implement the grouping relation? + for lang := t; ; lang = t.Parent() { + if p, ok := m[lang]; ok { + f.Pattern = *p + break + } + if lang == language.Und { + break + } + } + } +} + +// FormatWidth sets the total format width. +func FormatWidth(n int) Option { + if n <= 0 { + return noop + } + return func(t language.Tag, f *number.Formatter) { + f.FormatWidth = uint16(n) + if f.PadRune == 0 { + f.PadRune = ' ' + } + } +} + +// Pad sets the rune to be used for filling up to the format width. +func Pad(r rune) Option { + return func(t language.Tag, f *number.Formatter) { + f.PadRune = r + } +} + +// TODO: +// - FormatPosition (using type aliasing?) +// - Multiplier: find a better way to represent and figure out what to do +// with clashes with percent/permille. +// - NumberingSystem(nu string): not accessable in number.Info now. Also, should +// this be keyed by language or generic? +// - SymbolOverrides(symbols map[string]map[number.SymbolType]string) Option -- cgit v1.2.3