summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/text/number/option.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/text/number/option.go')
-rw-r--r--vendor/golang.org/x/text/number/option.go177
1 files changed, 177 insertions, 0 deletions
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