From 473acc61c8392dc7ae303d91568e179c4f105a76 Mon Sep 17 00:00:00 2001 From: Dimitri Sokolyuk Date: Tue, 2 Jul 2019 12:12:53 +0200 Subject: add black list --- vendor/golang.org/x/text/number/option.go | 177 ------------------------------ 1 file changed, 177 deletions(-) delete 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 deleted file mode 100644 index de96f8e..0000000 --- a/vendor/golang.org/x/text/number/option.go +++ /dev/null @@ -1,177 +0,0 @@ -// 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