vendor/github.com/spf13/pflag/float64.go

   1 package pflag
   2
   3 import "strconv"
   4
   5 // -- float64 Value
   6 type float64Value float64
   7
   8 func newFloat64Value(val float64, p *float64) *float64Value {
   9         *p = val
  10         return (*float64Value)(p)
  11 }
  12
  13 func (f *float64Value) Set(s string) error {
  14         v, err := strconv.ParseFloat(s, 64)
  15         *f = float64Value(v)
  16         return err
  17 }
  18
  19 func (f *float64Value) Type() string {
  20         return "float64"
  21 }
  22
  23 func (f *float64Value) String() string { return strconv.FormatFloat(float64(*f), 'g', -1, 64) }
  24
  25 func float64Conv(sval string) (interface{}, error) {
  26         return strconv.ParseFloat(sval, 64)
  27 }
  28
  29 // GetFloat64 return the float64 value of a flag with the given name
  30 func (f *FlagSet) GetFloat64(name string) (float64, error) {
  31         val, err := f.getFlagType(name, "float64", float64Conv)
  32         if err != nil {
  33                 return 0, err
  34         }
  35         return val.(float64), nil
  36 }
  37
  38 // Float64Var defines a float64 flag with specified name, default value, and usage string.
  39 // The argument p points to a float64 variable in which to store the value of the flag.
  40 func (f *FlagSet) Float64Var(p *float64, name string, value float64, usage string) {
  41         f.VarP(newFloat64Value(value, p), name, "", usage)
  42 }
  43
  44 // Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.
  45 func (f *FlagSet) Float64VarP(p *float64, name, shorthand string, value float64, usage string) {
  46         f.VarP(newFloat64Value(value, p), name, shorthand, usage)
  47 }
  48
  49 // Float64Var defines a float64 flag with specified name, default value, and usage string.
  50 // The argument p points to a float64 variable in which to store the value of the flag.
  51 func Float64Var(p *float64, name string, value float64, usage string) {
  52         CommandLine.VarP(newFloat64Value(value, p), name, "", usage)
  53 }
  54
  55 // Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.
  56 func Float64VarP(p *float64, name, shorthand string, value float64, usage string) {
  57         CommandLine.VarP(newFloat64Value(value, p), name, shorthand, usage)
  58 }
  59
  60 // Float64 defines a float64 flag with specified name, default value, and usage string.
  61 // The return value is the address of a float64 variable that stores the value of the flag.
  62 func (f *FlagSet) Float64(name string, value float64, usage string) *float64 {
  63         p := new(float64)
  64         f.Float64VarP(p, name, "", value, usage)
  65         return p
  66 }
  67
  68 // Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.
  69 func (f *FlagSet) Float64P(name, shorthand string, value float64, usage string) *float64 {
  70         p := new(float64)
  71         f.Float64VarP(p, name, shorthand, value, usage)
  72         return p
  73 }
  74
  75 // Float64 defines a float64 flag with specified name, default value, and usage string.
  76 // The return value is the address of a float64 variable that stores the value of the flag.
  77 func Float64(name string, value float64, usage string) *float64 {
  78         return CommandLine.Float64P(name, "", value, usage)
  79 }
  80
  81 // Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.
  82 func Float64P(name, shorthand string, value float64, usage string) *float64 {
  83         return CommandLine.Float64P(name, shorthand, value, usage)
  84 }