Fix up minor things found by goreportcard.com
diff --git a/bool.go b/bool.go
index 04c9b5a..d272e40 100644
--- a/bool.go
+++ b/bool.go
@@ -53,7 +53,7 @@
f.BoolVarP(p, name, "", value, usage)
}
-// Like BoolVar, but accepts a shorthand letter that can be used after a single dash.
+// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) BoolVarP(p *bool, name, shorthand string, value bool, usage string) {
flag := f.VarPF(newBoolValue(value, p), name, shorthand, usage)
flag.NoOptDefVal = "true"
@@ -65,7 +65,7 @@
BoolVarP(p, name, "", value, usage)
}
-// Like BoolVar, but accepts a shorthand letter that can be used after a single dash.
+// BoolVarP is like BoolVar, but accepts a shorthand letter that can be used after a single dash.
func BoolVarP(p *bool, name, shorthand string, value bool, usage string) {
flag := CommandLine.VarPF(newBoolValue(value, p), name, shorthand, usage)
flag.NoOptDefVal = "true"
@@ -77,7 +77,7 @@
return f.BoolP(name, "", value, usage)
}
-// Like Bool, but accepts a shorthand letter that can be used after a single dash.
+// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) BoolP(name, shorthand string, value bool, usage string) *bool {
p := new(bool)
f.BoolVarP(p, name, shorthand, value, usage)
@@ -90,7 +90,7 @@
return BoolP(name, "", value, usage)
}
-// Like Bool, but accepts a shorthand letter that can be used after a single dash.
+// BoolP is like Bool, but accepts a shorthand letter that can be used after a single dash.
func BoolP(name, shorthand string, value bool, usage string) *bool {
b := CommandLine.BoolP(name, shorthand, value, usage)
return b
diff --git a/count.go b/count.go
index d061368..7b1f142 100644
--- a/count.go
+++ b/count.go
@@ -38,6 +38,7 @@
return i, nil
}
+// GetCount return the int value of a flag with the given name
func (f *FlagSet) GetCount(name string) (int, error) {
val, err := f.getFlagType(name, "count", countConv)
if err != nil {
@@ -46,39 +47,51 @@
return val.(int), nil
}
+// CountVar defines a count flag with specified name, default value, and usage string.
+// The argument p points to an int variable in which to store the value of the flag.
+// A count flag will add 1 to its value evey time it is found on the command line
func (f *FlagSet) CountVar(p *int, name string, usage string) {
f.CountVarP(p, name, "", usage)
}
+// CountVarP is like CountVar only take a shorthand for the flag name.
func (f *FlagSet) CountVarP(p *int, name, shorthand string, usage string) {
flag := f.VarPF(newCountValue(0, p), name, shorthand, usage)
flag.NoOptDefVal = "-1"
}
+// CountVar like CountVar only the flag is placed on the CommandLine instead of a given flag set
func CountVar(p *int, name string, usage string) {
CommandLine.CountVar(p, name, usage)
}
+// CountVarP is like CountVar only take a shorthand for the flag name.
func CountVarP(p *int, name, shorthand string, usage string) {
CommandLine.CountVarP(p, name, shorthand, usage)
}
+// Count defines a count flag with specified name, default value, and usage string.
+// The return value is the address of an int variable that stores the value of the flag.
+// A count flag will add 1 to its value evey time it is found on the command line
func (f *FlagSet) Count(name string, usage string) *int {
p := new(int)
f.CountVarP(p, name, "", usage)
return p
}
+// CountP is like Count only takes a shorthand for the flag name.
func (f *FlagSet) CountP(name, shorthand string, usage string) *int {
p := new(int)
f.CountVarP(p, name, shorthand, usage)
return p
}
+// Count like Count only the flag is placed on the CommandLine isntead of a given flag set
func Count(name string, usage string) *int {
return CommandLine.CountP(name, "", usage)
}
+// CountP is like Count only takes a shorthand for the flag name.
func CountP(name, shorthand string, usage string) *int {
return CommandLine.CountP(name, shorthand, usage)
}
diff --git a/duration.go b/duration.go
index 382ffd3..e9debef 100644
--- a/duration.go
+++ b/duration.go
@@ -43,7 +43,7 @@
f.VarP(newDurationValue(value, p), name, "", usage)
}
-// Like DurationVar, but accepts a shorthand letter that can be used after a single dash.
+// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) {
f.VarP(newDurationValue(value, p), name, shorthand, usage)
}
@@ -54,7 +54,7 @@
CommandLine.VarP(newDurationValue(value, p), name, "", usage)
}
-// Like DurationVar, but accepts a shorthand letter that can be used after a single dash.
+// DurationVarP is like DurationVar, but accepts a shorthand letter that can be used after a single dash.
func DurationVarP(p *time.Duration, name, shorthand string, value time.Duration, usage string) {
CommandLine.VarP(newDurationValue(value, p), name, shorthand, usage)
}
@@ -67,7 +67,7 @@
return p
}
-// Like Duration, but accepts a shorthand letter that can be used after a single dash.
+// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration {
p := new(time.Duration)
f.DurationVarP(p, name, shorthand, value, usage)
@@ -80,7 +80,7 @@
return CommandLine.DurationP(name, "", value, usage)
}
-// Like Duration, but accepts a shorthand letter that can be used after a single dash.
+// DurationP is like Duration, but accepts a shorthand letter that can be used after a single dash.
func DurationP(name, shorthand string, value time.Duration, usage string) *time.Duration {
return CommandLine.DurationP(name, shorthand, value, usage)
}
diff --git a/flag.go b/flag.go
index 0dce0a3..12d718b 100644
--- a/flag.go
+++ b/flag.go
@@ -3,98 +3,98 @@
// license that can be found in the LICENSE file.
/*
- pflag is a drop-in replacement for Go's flag package, implementing
- POSIX/GNU-style --flags.
+Package pflag is a drop-in replacement for Go's flag package, implementing
+POSIX/GNU-style --flags.
- pflag is compatible with the GNU extensions to the POSIX recommendations
- for command-line options. See
- http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html
+pflag is compatible with the GNU extensions to the POSIX recommendations
+for command-line options. See
+http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html
- Usage:
+Usage:
- pflag is a drop-in replacement of Go's native flag package. If you import
- pflag under the name "flag" then all code should continue to function
- with no changes.
+pflag is a drop-in replacement of Go's native flag package. If you import
+pflag under the name "flag" then all code should continue to function
+with no changes.
- import flag "github.com/ogier/pflag"
+ import flag "github.com/ogier/pflag"
There is one exception to this: if you directly instantiate the Flag struct
- there is one more field "Shorthand" that you will need to set.
- Most code never instantiates this struct directly, and instead uses
- functions such as String(), BoolVar(), and Var(), and is therefore
- unaffected.
+there is one more field "Shorthand" that you will need to set.
+Most code never instantiates this struct directly, and instead uses
+functions such as String(), BoolVar(), and Var(), and is therefore
+unaffected.
- Define flags using flag.String(), Bool(), Int(), etc.
+Define flags using flag.String(), Bool(), Int(), etc.
- This declares an integer flag, -flagname, stored in the pointer ip, with type *int.
- var ip = flag.Int("flagname", 1234, "help message for flagname")
- If you like, you can bind the flag to a variable using the Var() functions.
- var flagvar int
- func init() {
- flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname")
- }
- Or you can create custom flags that satisfy the Value interface (with
- pointer receivers) and couple them to flag parsing by
- flag.Var(&flagVal, "name", "help message for flagname")
- For such flags, the default value is just the initial value of the variable.
+This declares an integer flag, -flagname, stored in the pointer ip, with type *int.
+ var ip = flag.Int("flagname", 1234, "help message for flagname")
+If you like, you can bind the flag to a variable using the Var() functions.
+ var flagvar int
+ func init() {
+ flag.IntVar(&flagvar, "flagname", 1234, "help message for flagname")
+ }
+Or you can create custom flags that satisfy the Value interface (with
+pointer receivers) and couple them to flag parsing by
+ flag.Var(&flagVal, "name", "help message for flagname")
+For such flags, the default value is just the initial value of the variable.
- After all flags are defined, call
- flag.Parse()
- to parse the command line into the defined flags.
+After all flags are defined, call
+ flag.Parse()
+to parse the command line into the defined flags.
- Flags may then be used directly. If you're using the flags themselves,
- they are all pointers; if you bind to variables, they're values.
- fmt.Println("ip has value ", *ip)
- fmt.Println("flagvar has value ", flagvar)
+Flags may then be used directly. If you're using the flags themselves,
+they are all pointers; if you bind to variables, they're values.
+ fmt.Println("ip has value ", *ip)
+ fmt.Println("flagvar has value ", flagvar)
- After parsing, the arguments after the flag are available as the
- slice flag.Args() or individually as flag.Arg(i).
- The arguments are indexed from 0 through flag.NArg()-1.
+After parsing, the arguments after the flag are available as the
+slice flag.Args() or individually as flag.Arg(i).
+The arguments are indexed from 0 through flag.NArg()-1.
- The pflag package also defines some new functions that are not in flag,
- that give one-letter shorthands for flags. You can use these by appending
- 'P' to the name of any function that defines a flag.
- var ip = flag.IntP("flagname", "f", 1234, "help message")
- var flagvar bool
- func init() {
- flag.BoolVarP("boolname", "b", true, "help message")
- }
- flag.VarP(&flagVar, "varname", "v", 1234, "help message")
- Shorthand letters can be used with single dashes on the command line.
- Boolean shorthand flags can be combined with other shorthand flags.
+The pflag package also defines some new functions that are not in flag,
+that give one-letter shorthands for flags. You can use these by appending
+'P' to the name of any function that defines a flag.
+ var ip = flag.IntP("flagname", "f", 1234, "help message")
+ var flagvar bool
+ func init() {
+ flag.BoolVarP("boolname", "b", true, "help message")
+ }
+ flag.VarP(&flagVar, "varname", "v", 1234, "help message")
+Shorthand letters can be used with single dashes on the command line.
+Boolean shorthand flags can be combined with other shorthand flags.
- Command line flag syntax:
- --flag // boolean flags only
- --flag=x
+Command line flag syntax:
+ --flag // boolean flags only
+ --flag=x
- Unlike the flag package, a single dash before an option means something
- different than a double dash. Single dashes signify a series of shorthand
- letters for flags. All but the last shorthand letter must be boolean flags.
- // boolean flags
- -f
- -abc
- // non-boolean flags
- -n 1234
- -Ifile
- // mixed
- -abcs "hello"
- -abcn1234
+Unlike the flag package, a single dash before an option means something
+different than a double dash. Single dashes signify a series of shorthand
+letters for flags. All but the last shorthand letter must be boolean flags.
+ // boolean flags
+ -f
+ -abc
+ // non-boolean flags
+ -n 1234
+ -Ifile
+ // mixed
+ -abcs "hello"
+ -abcn1234
- Flag parsing stops after the terminator "--". Unlike the flag package,
- flags can be interspersed with arguments anywhere on the command line
- before this terminator.
+Flag parsing stops after the terminator "--". Unlike the flag package,
+flags can be interspersed with arguments anywhere on the command line
+before this terminator.
- Integer flags accept 1234, 0664, 0x1234 and may be negative.
- Boolean flags (in their long form) accept 1, 0, t, f, true, false,
- TRUE, FALSE, True, False.
- Duration flags accept any input valid for time.ParseDuration.
+Integer flags accept 1234, 0664, 0x1234 and may be negative.
+Boolean flags (in their long form) accept 1, 0, t, f, true, false,
+TRUE, FALSE, True, False.
+Duration flags accept any input valid for time.ParseDuration.
- The default set of command-line flags is controlled by
- top-level functions. The FlagSet type allows one to define
- independent sets of flags, such as to implement subcommands
- in a command-line interface. The methods of FlagSet are
- analogous to the top-level functions for the command-line
- flag set.
+The default set of command-line flags is controlled by
+top-level functions. The FlagSet type allows one to define
+independent sets of flags, such as to implement subcommands
+in a command-line interface. The methods of FlagSet are
+analogous to the top-level functions for the command-line
+flag set.
*/
package pflag
@@ -115,8 +115,11 @@
type ErrorHandling int
const (
+ // ContinueOnError will return an err from Parse() if an error is found
ContinueOnError ErrorHandling = iota
+ // ExitOnError will call os.Exit(2) if an error is found when parsing
ExitOnError
+ // PanicOnError will panic() if an error is found when parsing flags
PanicOnError
)
@@ -181,6 +184,11 @@
return result
}
+// SetNormalizeFunc allows you to add a function which can translate flag names.
+// Flags added to the FlagSet will be translated and then when anything tries to
+// look up the flag that will also be translated. So it would be possible to create
+// a flag named "getURL" and have it translated to "geturl". A user could then pass
+// "--getUrl" which may also be translated to "geturl" and everything will work.
func (f *FlagSet) SetNormalizeFunc(n func(f *FlagSet, name string) NormalizedName) {
f.normalizeNameFunc = n
for k, v := range f.formal {
@@ -191,6 +199,8 @@
}
}
+// GetNormalizeFunc returns the previously set NormalizeFunc of a function which
+// does no translation, if not set previously.
func (f *FlagSet) GetNormalizeFunc() func(f *FlagSet, name string) NormalizedName {
if f.normalizeNameFunc != nil {
return f.normalizeNameFunc
@@ -224,6 +234,7 @@
}
}
+// HasFlags returns a bool to indicate if the FlagSet has any flags definied.
func (f *FlagSet) HasFlags() bool {
return len(f.formal) > 0
}
@@ -279,7 +290,9 @@
return result, nil
}
-// Mark a flag deprecated in your program
+// MarkDeprecated indicated that a flag is deprecated in your program. It will
+// continue to function but will not show up in help or usage messages. Using
+// this flag will also print the given usageMessage.
func (f *FlagSet) MarkDeprecated(name string, usageMessage string) error {
flag := f.Lookup(name)
if flag == nil {
@@ -317,6 +330,9 @@
return nil
}
+// SetAnnotation allows one to set arbitrary annotations on a flag in the FlagSet.
+// This is sometimes used by spf13/cobra programs which want to generate additional
+// bash completion information.
func (f *FlagSet) SetAnnotation(name, key string, values []string) error {
normalName := f.normalizeFlagName(name)
flag, ok := f.formal[normalName]
@@ -330,6 +346,8 @@
return nil
}
+// Changed returns true if the flag was explicitly set during Parse() and false
+// otherwise
func (f *FlagSet) Changed(name string) bool {
flag := f.Lookup(name)
// If a flag doesn't exist, it wasn't changed....
@@ -374,6 +392,8 @@
})
}
+// FlagUsages Returns a string containing the usage information for all flags in
+// the FlagSet
func (f *FlagSet) FlagUsages() string {
x := new(bytes.Buffer)
@@ -471,7 +491,7 @@
f.VarP(value, name, "", usage)
}
-// Like VarP, but returns the flag created
+// VarPF is like VarP, but returns the flag created
func (f *FlagSet) VarPF(value Value, name, shorthand, usage string) *Flag {
// Remember the default value as a string; it won't change.
flag := &Flag{
@@ -485,14 +505,15 @@
return flag
}
-// Like Var, but accepts a shorthand letter that can be used after a single dash.
+// VarP is like Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) VarP(value Value, name, shorthand, usage string) {
_ = f.VarPF(value, name, shorthand, usage)
}
+// AddFlag will add the flag to the FlagSet
func (f *FlagSet) AddFlag(flag *Flag) {
// Call normalizeFlagName function only once
- var normalizedFlagName NormalizedName = f.normalizeFlagName(flag.Name)
+ normalizedFlagName := f.normalizeFlagName(flag.Name)
_, alreadythere := f.formal[normalizedFlagName]
if alreadythere {
@@ -536,7 +557,7 @@
CommandLine.VarP(value, name, "", usage)
}
-// Like Var, but accepts a shorthand letter that can be used after a single dash.
+// VarP is like Var, but accepts a shorthand letter that can be used after a single dash.
func VarP(value Value, name, shorthand, usage string) {
CommandLine.VarP(value, name, shorthand, usage)
}
@@ -729,7 +750,7 @@
CommandLine.Parse(os.Args[1:])
}
-// Whether to support interspersed option/non-option arguments.
+// SetInterspersed sets whether to support interspersed option/non-option arguments.
func SetInterspersed(interspersed bool) {
CommandLine.SetInterspersed(interspersed)
}
@@ -753,7 +774,7 @@
return f
}
-// Whether to support interspersed option/non-option arguments.
+// SetIntersperesed sets whether to support interspersed option/non-option arguments.
func (f *FlagSet) SetInterspersed(interspersed bool) {
f.interspersed = interspersed
}
diff --git a/flag_test.go b/flag_test.go
index e654553..9ff1934 100644
--- a/flag_test.go
+++ b/flag_test.go
@@ -19,15 +19,15 @@
)
var (
- test_bool = Bool("test_bool", false, "bool value")
- test_int = Int("test_int", 0, "int value")
- test_int64 = Int64("test_int64", 0, "int64 value")
- test_uint = Uint("test_uint", 0, "uint value")
- test_uint64 = Uint64("test_uint64", 0, "uint64 value")
- test_string = String("test_string", "0", "string value")
- test_float64 = Float64("test_float64", 0, "float64 value")
- test_duration = Duration("test_duration", 0, "time.Duration value")
- test_optional_int = Int("test_optional_int", 0, "optional int value")
+ testBool = Bool("test_bool", false, "bool value")
+ testInt = Int("test_int", 0, "int value")
+ testInt64 = Int64("test_int64", 0, "int64 value")
+ testUint = Uint("test_uint", 0, "uint value")
+ testUint64 = Uint64("test_uint64", 0, "uint64 value")
+ testString = String("test_string", "0", "string value")
+ testFloat = Float64("test_float64", 0, "float64 value")
+ testDuration = Duration("test_duration", 0, "time.Duration value")
+ testOptionalInt = Int("test_optional_int", 0, "optional int value")
normalizeFlagNameInvocations = 0
)
@@ -291,7 +291,7 @@
t.Error("mask flag should be 255.255.255.0, is ", (*maskFlag).String())
}
if v, err := f.GetIPv4Mask("mask"); err != nil || v.String() != (*maskFlag).String() {
- t.Errorf("GetIP returned %v but maskFlag was %v", v, *maskFlag, err)
+ t.Errorf("GetIP returned %v maskFlag was %v error was %v", v, *maskFlag, err)
}
if *durationFlag != 2*time.Minute {
t.Error("duration flag should be 2m, is ", *durationFlag)
diff --git a/float32.go b/float32.go
index 30174cb..7683fae 100644
--- a/float32.go
+++ b/float32.go
@@ -48,7 +48,7 @@
f.VarP(newFloat32Value(value, p), name, "", usage)
}
-// Like Float32Var, but accepts a shorthand letter that can be used after a single dash.
+// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Float32VarP(p *float32, name, shorthand string, value float32, usage string) {
f.VarP(newFloat32Value(value, p), name, shorthand, usage)
}
@@ -59,7 +59,7 @@
CommandLine.VarP(newFloat32Value(value, p), name, "", usage)
}
-// Like Float32Var, but accepts a shorthand letter that can be used after a single dash.
+// Float32VarP is like Float32Var, but accepts a shorthand letter that can be used after a single dash.
func Float32VarP(p *float32, name, shorthand string, value float32, usage string) {
CommandLine.VarP(newFloat32Value(value, p), name, shorthand, usage)
}
@@ -72,7 +72,7 @@
return p
}
-// Like Float32, but accepts a shorthand letter that can be used after a single dash.
+// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Float32P(name, shorthand string, value float32, usage string) *float32 {
p := new(float32)
f.Float32VarP(p, name, shorthand, value, usage)
@@ -85,7 +85,7 @@
return CommandLine.Float32P(name, "", value, usage)
}
-// Like Float32, but accepts a shorthand letter that can be used after a single dash.
+// Float32P is like Float32, but accepts a shorthand letter that can be used after a single dash.
func Float32P(name, shorthand string, value float32, usage string) *float32 {
return CommandLine.Float32P(name, shorthand, value, usage)
}
diff --git a/float64.go b/float64.go
index 10e17e4..50fbf8c 100644
--- a/float64.go
+++ b/float64.go
@@ -44,7 +44,7 @@
f.VarP(newFloat64Value(value, p), name, "", usage)
}
-// Like Float64Var, but accepts a shorthand letter that can be used after a single dash.
+// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Float64VarP(p *float64, name, shorthand string, value float64, usage string) {
f.VarP(newFloat64Value(value, p), name, shorthand, usage)
}
@@ -55,7 +55,7 @@
CommandLine.VarP(newFloat64Value(value, p), name, "", usage)
}
-// Like Float64Var, but accepts a shorthand letter that can be used after a single dash.
+// Float64VarP is like Float64Var, but accepts a shorthand letter that can be used after a single dash.
func Float64VarP(p *float64, name, shorthand string, value float64, usage string) {
CommandLine.VarP(newFloat64Value(value, p), name, shorthand, usage)
}
@@ -68,7 +68,7 @@
return p
}
-// Like Float64, but accepts a shorthand letter that can be used after a single dash.
+// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Float64P(name, shorthand string, value float64, usage string) *float64 {
p := new(float64)
f.Float64VarP(p, name, shorthand, value, usage)
@@ -81,7 +81,7 @@
return CommandLine.Float64P(name, "", value, usage)
}
-// Like Float64, but accepts a shorthand letter that can be used after a single dash.
+// Float64P is like Float64, but accepts a shorthand letter that can be used after a single dash.
func Float64P(name, shorthand string, value float64, usage string) *float64 {
return CommandLine.Float64P(name, shorthand, value, usage)
}
diff --git a/int.go b/int.go
index 23f70dd..b656036 100644
--- a/int.go
+++ b/int.go
@@ -44,7 +44,7 @@
f.VarP(newIntValue(value, p), name, "", usage)
}
-// Like IntVar, but accepts a shorthand letter that can be used after a single dash.
+// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IntVarP(p *int, name, shorthand string, value int, usage string) {
f.VarP(newIntValue(value, p), name, shorthand, usage)
}
@@ -55,7 +55,7 @@
CommandLine.VarP(newIntValue(value, p), name, "", usage)
}
-// Like IntVar, but accepts a shorthand letter that can be used after a single dash.
+// IntVarP is like IntVar, but accepts a shorthand letter that can be used after a single dash.
func IntVarP(p *int, name, shorthand string, value int, usage string) {
CommandLine.VarP(newIntValue(value, p), name, shorthand, usage)
}
@@ -68,7 +68,7 @@
return p
}
-// Like Int, but accepts a shorthand letter that can be used after a single dash.
+// IntP is like Int, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IntP(name, shorthand string, value int, usage string) *int {
p := new(int)
f.IntVarP(p, name, shorthand, value, usage)
@@ -81,7 +81,7 @@
return CommandLine.IntP(name, "", value, usage)
}
-// Like Int, but accepts a shorthand letter that can be used after a single dash.
+// IntP is like Int, but accepts a shorthand letter that can be used after a single dash.
func IntP(name, shorthand string, value int, usage string) *int {
return CommandLine.IntP(name, shorthand, value, usage)
}
diff --git a/int32.go b/int32.go
index 515f90b..41659a9 100644
--- a/int32.go
+++ b/int32.go
@@ -48,7 +48,7 @@
f.VarP(newInt32Value(value, p), name, "", usage)
}
-// Like Int32Var, but accepts a shorthand letter that can be used after a single dash.
+// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Int32VarP(p *int32, name, shorthand string, value int32, usage string) {
f.VarP(newInt32Value(value, p), name, shorthand, usage)
}
@@ -59,7 +59,7 @@
CommandLine.VarP(newInt32Value(value, p), name, "", usage)
}
-// Like Int32Var, but accepts a shorthand letter that can be used after a single dash.
+// Int32VarP is like Int32Var, but accepts a shorthand letter that can be used after a single dash.
func Int32VarP(p *int32, name, shorthand string, value int32, usage string) {
CommandLine.VarP(newInt32Value(value, p), name, shorthand, usage)
}
@@ -72,7 +72,7 @@
return p
}
-// Like Int32, but accepts a shorthand letter that can be used after a single dash.
+// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Int32P(name, shorthand string, value int32, usage string) *int32 {
p := new(int32)
f.Int32VarP(p, name, shorthand, value, usage)
@@ -85,7 +85,7 @@
return CommandLine.Int32P(name, "", value, usage)
}
-// Like Int32, but accepts a shorthand letter that can be used after a single dash.
+// Int32P is like Int32, but accepts a shorthand letter that can be used after a single dash.
func Int32P(name, shorthand string, value int32, usage string) *int32 {
return CommandLine.Int32P(name, shorthand, value, usage)
}
diff --git a/int64.go b/int64.go
index b77ade4..6e67e38 100644
--- a/int64.go
+++ b/int64.go
@@ -44,7 +44,7 @@
f.VarP(newInt64Value(value, p), name, "", usage)
}
-// Like Int64Var, but accepts a shorthand letter that can be used after a single dash.
+// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Int64VarP(p *int64, name, shorthand string, value int64, usage string) {
f.VarP(newInt64Value(value, p), name, shorthand, usage)
}
@@ -55,7 +55,7 @@
CommandLine.VarP(newInt64Value(value, p), name, "", usage)
}
-// Like Int64Var, but accepts a shorthand letter that can be used after a single dash.
+// Int64VarP is like Int64Var, but accepts a shorthand letter that can be used after a single dash.
func Int64VarP(p *int64, name, shorthand string, value int64, usage string) {
CommandLine.VarP(newInt64Value(value, p), name, shorthand, usage)
}
@@ -68,7 +68,7 @@
return p
}
-// Like Int64, but accepts a shorthand letter that can be used after a single dash.
+// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Int64P(name, shorthand string, value int64, usage string) *int64 {
p := new(int64)
f.Int64VarP(p, name, shorthand, value, usage)
@@ -81,7 +81,7 @@
return CommandLine.Int64P(name, "", value, usage)
}
-// Like Int64, but accepts a shorthand letter that can be used after a single dash.
+// Int64P is like Int64, but accepts a shorthand letter that can be used after a single dash.
func Int64P(name, shorthand string, value int64, usage string) *int64 {
return CommandLine.Int64P(name, shorthand, value, usage)
}
diff --git a/int8.go b/int8.go
index c51cb4f..400db21 100644
--- a/int8.go
+++ b/int8.go
@@ -48,7 +48,7 @@
f.VarP(newInt8Value(value, p), name, "", usage)
}
-// Like Int8Var, but accepts a shorthand letter that can be used after a single dash.
+// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Int8VarP(p *int8, name, shorthand string, value int8, usage string) {
f.VarP(newInt8Value(value, p), name, shorthand, usage)
}
@@ -59,7 +59,7 @@
CommandLine.VarP(newInt8Value(value, p), name, "", usage)
}
-// Like Int8Var, but accepts a shorthand letter that can be used after a single dash.
+// Int8VarP is like Int8Var, but accepts a shorthand letter that can be used after a single dash.
func Int8VarP(p *int8, name, shorthand string, value int8, usage string) {
CommandLine.VarP(newInt8Value(value, p), name, shorthand, usage)
}
@@ -72,7 +72,7 @@
return p
}
-// Like Int8, but accepts a shorthand letter that can be used after a single dash.
+// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Int8P(name, shorthand string, value int8, usage string) *int8 {
p := new(int8)
f.Int8VarP(p, name, shorthand, value, usage)
@@ -85,7 +85,7 @@
return CommandLine.Int8P(name, "", value, usage)
}
-// Like Int8, but accepts a shorthand letter that can be used after a single dash.
+// Int8P is like Int8, but accepts a shorthand letter that can be used after a single dash.
func Int8P(name, shorthand string, value int8, usage string) *int8 {
return CommandLine.Int8P(name, shorthand, value, usage)
}
diff --git a/int_slice.go b/int_slice.go
index 7c6ed79..1e7c9ed 100644
--- a/int_slice.go
+++ b/int_slice.go
@@ -85,7 +85,7 @@
f.VarP(newIntSliceValue(value, p), name, "", usage)
}
-// Like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.
+// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) {
f.VarP(newIntSliceValue(value, p), name, shorthand, usage)
}
@@ -96,7 +96,7 @@
CommandLine.VarP(newIntSliceValue(value, p), name, "", usage)
}
-// Like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.
+// IntSliceVarP is like IntSliceVar, but accepts a shorthand letter that can be used after a single dash.
func IntSliceVarP(p *[]int, name, shorthand string, value []int, usage string) {
CommandLine.VarP(newIntSliceValue(value, p), name, shorthand, usage)
}
@@ -104,14 +104,14 @@
// IntSlice defines a []int flag with specified name, default value, and usage string.
// The return value is the address of a []int variable that stores the value of the flag.
func (f *FlagSet) IntSlice(name string, value []int, usage string) *[]int {
- p := make([]int, 0)
+ p := []int{}
f.IntSliceVarP(&p, name, "", value, usage)
return &p
}
-// Like IntSlice, but accepts a shorthand letter that can be used after a single dash.
+// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IntSliceP(name, shorthand string, value []int, usage string) *[]int {
- p := make([]int, 0)
+ p := []int{}
f.IntSliceVarP(&p, name, shorthand, value, usage)
return &p
}
@@ -122,7 +122,7 @@
return CommandLine.IntSliceP(name, "", value, usage)
}
-// Like IntSlice, but accepts a shorthand letter that can be used after a single dash.
+// IntSliceP is like IntSlice, but accepts a shorthand letter that can be used after a single dash.
func IntSliceP(name, shorthand string, value []int, usage string) *[]int {
return CommandLine.IntSliceP(name, shorthand, value, usage)
}
diff --git a/int_slice_test.go b/int_slice_test.go
index 13a6551..5f2eee6 100644
--- a/int_slice_test.go
+++ b/int_slice_test.go
@@ -87,7 +87,7 @@
t.Fatalf("got error: %v", err)
}
if d != v {
- t.Fatalf("expected is[%d] to be %s but got: %s", i, d, v)
+ t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
}
}
@@ -101,7 +101,7 @@
t.Fatal("got an error from GetIntSlice():", err)
}
if d != v {
- t.Fatalf("expected is[%d] to be %s from GetIntSlice but got: %s", i, d, v)
+ t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
}
}
}
@@ -122,7 +122,7 @@
t.Fatalf("got error: %v", err)
}
if d != v {
- t.Fatalf("expected is[%d] to be %s but got: %s", i, d, v)
+ t.Fatalf("expected is[%d] to be %d but got: %d", i, d, v)
}
}
@@ -136,7 +136,7 @@
t.Fatalf("got error: %v", err)
}
if d != v {
- t.Fatalf("expected is[%d] to be %s from GetIntSlice but got: %s", i, d, v)
+ t.Fatalf("expected is[%d] to be %d from GetIntSlice but got: %d", i, d, v)
}
}
}
@@ -156,7 +156,7 @@
}
for i, v := range is {
if expected[i] != v {
- t.Fatalf("expected is[%d] to be %s but got: %s", i, expected[i], v)
+ t.Fatalf("expected is[%d] to be %d but got: %d", i, expected[i], v)
}
}
}
diff --git a/ip.go b/ip.go
index baa442b..88a1743 100644
--- a/ip.go
+++ b/ip.go
@@ -53,7 +53,7 @@
f.VarP(newIPValue(value, p), name, "", usage)
}
-// Like IPVar, but accepts a shorthand letter that can be used after a single dash.
+// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) {
f.VarP(newIPValue(value, p), name, shorthand, usage)
}
@@ -64,7 +64,7 @@
CommandLine.VarP(newIPValue(value, p), name, "", usage)
}
-// Like IPVar, but accepts a shorthand letter that can be used after a single dash.
+// IPVarP is like IPVar, but accepts a shorthand letter that can be used after a single dash.
func IPVarP(p *net.IP, name, shorthand string, value net.IP, usage string) {
CommandLine.VarP(newIPValue(value, p), name, shorthand, usage)
}
@@ -77,7 +77,7 @@
return p
}
-// Like IP, but accepts a shorthand letter that can be used after a single dash.
+// IPP is like IP, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IPP(name, shorthand string, value net.IP, usage string) *net.IP {
p := new(net.IP)
f.IPVarP(p, name, shorthand, value, usage)
@@ -90,7 +90,7 @@
return CommandLine.IPP(name, "", value, usage)
}
-// Like IP, but accepts a shorthand letter that can be used after a single dash.
+// IPP is like IP, but accepts a shorthand letter that can be used after a single dash.
func IPP(name, shorthand string, value net.IP, usage string) *net.IP {
return CommandLine.IPP(name, shorthand, value, usage)
}
diff --git a/ipmask.go b/ipmask.go
index 1b10efb..5bd44bd 100644
--- a/ipmask.go
+++ b/ipmask.go
@@ -28,7 +28,7 @@
return "ipMask"
}
-// Parse IPv4 netmask written in IP form (e.g. 255.255.255.0).
+// ParseIPv4Mask written in IP form (e.g. 255.255.255.0).
// This function should really belong to the net package.
func ParseIPv4Mask(s string) net.IPMask {
mask := net.ParseIP(s)
@@ -79,7 +79,7 @@
f.VarP(newIPMaskValue(value, p), name, "", usage)
}
-// Like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.
+// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) {
f.VarP(newIPMaskValue(value, p), name, shorthand, usage)
}
@@ -90,7 +90,7 @@
CommandLine.VarP(newIPMaskValue(value, p), name, "", usage)
}
-// Like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.
+// IPMaskVarP is like IPMaskVar, but accepts a shorthand letter that can be used after a single dash.
func IPMaskVarP(p *net.IPMask, name, shorthand string, value net.IPMask, usage string) {
CommandLine.VarP(newIPMaskValue(value, p), name, shorthand, usage)
}
@@ -103,7 +103,7 @@
return p
}
-// Like IPMask, but accepts a shorthand letter that can be used after a single dash.
+// IPMaskP is like IPMask, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask {
p := new(net.IPMask)
f.IPMaskVarP(p, name, shorthand, value, usage)
@@ -116,7 +116,7 @@
return CommandLine.IPMaskP(name, "", value, usage)
}
-// Like IP, but accepts a shorthand letter that can be used after a single dash.
+// IPMaskP is like IP, but accepts a shorthand letter that can be used after a single dash.
func IPMaskP(name, shorthand string, value net.IPMask, usage string) *net.IPMask {
return CommandLine.IPMaskP(name, shorthand, value, usage)
}
diff --git a/ipnet.go b/ipnet.go
index 23b7fd3..149b764 100644
--- a/ipnet.go
+++ b/ipnet.go
@@ -7,31 +7,31 @@
)
// IPNet adapts net.IPNet for use as a flag.
-type IPNetValue net.IPNet
+type ipNetValue net.IPNet
-func (ipnet IPNetValue) String() string {
+func (ipnet ipNetValue) String() string {
n := net.IPNet(ipnet)
return n.String()
}
-func (ipnet *IPNetValue) Set(value string) error {
+func (ipnet *ipNetValue) Set(value string) error {
_, n, err := net.ParseCIDR(strings.TrimSpace(value))
if err != nil {
return err
}
- *ipnet = IPNetValue(*n)
+ *ipnet = ipNetValue(*n)
return nil
}
-func (*IPNetValue) Type() string {
+func (*ipNetValue) Type() string {
return "ipNet"
}
var _ = strings.TrimSpace
-func newIPNetValue(val net.IPNet, p *net.IPNet) *IPNetValue {
+func newIPNetValue(val net.IPNet, p *net.IPNet) *ipNetValue {
*p = val
- return (*IPNetValue)(p)
+ return (*ipNetValue)(p)
}
func ipNetConv(sval string) (interface{}, error) {
@@ -57,7 +57,7 @@
f.VarP(newIPNetValue(value, p), name, "", usage)
}
-// Like IPNetVar, but accepts a shorthand letter that can be used after a single dash.
+// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) {
f.VarP(newIPNetValue(value, p), name, shorthand, usage)
}
@@ -68,7 +68,7 @@
CommandLine.VarP(newIPNetValue(value, p), name, "", usage)
}
-// Like IPNetVar, but accepts a shorthand letter that can be used after a single dash.
+// IPNetVarP is like IPNetVar, but accepts a shorthand letter that can be used after a single dash.
func IPNetVarP(p *net.IPNet, name, shorthand string, value net.IPNet, usage string) {
CommandLine.VarP(newIPNetValue(value, p), name, shorthand, usage)
}
@@ -81,7 +81,7 @@
return p
}
-// Like IPNet, but accepts a shorthand letter that can be used after a single dash.
+// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet {
p := new(net.IPNet)
f.IPNetVarP(p, name, shorthand, value, usage)
@@ -94,7 +94,7 @@
return CommandLine.IPNetP(name, "", value, usage)
}
-// Like IPNet, but accepts a shorthand letter that can be used after a single dash.
+// IPNetP is like IPNet, but accepts a shorthand letter that can be used after a single dash.
func IPNetP(name, shorthand string, value net.IPNet, usage string) *net.IPNet {
return CommandLine.IPNetP(name, shorthand, value, usage)
}
diff --git a/string.go b/string.go
index f89ea8b..e296136 100644
--- a/string.go
+++ b/string.go
@@ -39,7 +39,7 @@
f.VarP(newStringValue(value, p), name, "", usage)
}
-// Like StringVar, but accepts a shorthand letter that can be used after a single dash.
+// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) StringVarP(p *string, name, shorthand string, value string, usage string) {
f.VarP(newStringValue(value, p), name, shorthand, usage)
}
@@ -50,7 +50,7 @@
CommandLine.VarP(newStringValue(value, p), name, "", usage)
}
-// Like StringVar, but accepts a shorthand letter that can be used after a single dash.
+// StringVarP is like StringVar, but accepts a shorthand letter that can be used after a single dash.
func StringVarP(p *string, name, shorthand string, value string, usage string) {
CommandLine.VarP(newStringValue(value, p), name, shorthand, usage)
}
@@ -63,7 +63,7 @@
return p
}
-// Like String, but accepts a shorthand letter that can be used after a single dash.
+// StringP is like String, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) StringP(name, shorthand string, value string, usage string) *string {
p := new(string)
f.StringVarP(p, name, shorthand, value, usage)
@@ -76,7 +76,7 @@
return CommandLine.StringP(name, "", value, usage)
}
-// Like String, but accepts a shorthand letter that can be used after a single dash.
+// StringP is like String, but accepts a shorthand letter that can be used after a single dash.
func StringP(name, shorthand string, value string, usage string) *string {
return CommandLine.StringP(name, shorthand, value, usage)
}
diff --git a/string_slice.go b/string_slice.go
index 848bea8..0b7ddfe 100644
--- a/string_slice.go
+++ b/string_slice.go
@@ -62,7 +62,7 @@
f.VarP(newStringSliceValue(value, p), name, "", usage)
}
-// Like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
+// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {
f.VarP(newStringSliceValue(value, p), name, shorthand, usage)
}
@@ -73,7 +73,7 @@
CommandLine.VarP(newStringSliceValue(value, p), name, "", usage)
}
-// Like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
+// StringSliceVarP is like StringSliceVar, but accepts a shorthand letter that can be used after a single dash.
func StringSliceVarP(p *[]string, name, shorthand string, value []string, usage string) {
CommandLine.VarP(newStringSliceValue(value, p), name, shorthand, usage)
}
@@ -81,14 +81,14 @@
// StringSlice defines a string flag with specified name, default value, and usage string.
// The return value is the address of a []string variable that stores the value of the flag.
func (f *FlagSet) StringSlice(name string, value []string, usage string) *[]string {
- p := make([]string, 0)
+ p := []string{}
f.StringSliceVarP(&p, name, "", value, usage)
return &p
}
-// Like StringSlice, but accepts a shorthand letter that can be used after a single dash.
+// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) StringSliceP(name, shorthand string, value []string, usage string) *[]string {
- p := make([]string, 0)
+ p := []string{}
f.StringSliceVarP(&p, name, shorthand, value, usage)
return &p
}
@@ -99,7 +99,7 @@
return CommandLine.StringSliceP(name, "", value, usage)
}
-// Like StringSlice, but accepts a shorthand letter that can be used after a single dash.
+// StringSliceP is like StringSlice, but accepts a shorthand letter that can be used after a single dash.
func StringSliceP(name, shorthand string, value []string, usage string) *[]string {
return CommandLine.StringSliceP(name, shorthand, value, usage)
}
diff --git a/uint.go b/uint.go
index d6f8e5b..e142b49 100644
--- a/uint.go
+++ b/uint.go
@@ -48,7 +48,7 @@
f.VarP(newUintValue(value, p), name, "", usage)
}
-// Like UintVar, but accepts a shorthand letter that can be used after a single dash.
+// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) UintVarP(p *uint, name, shorthand string, value uint, usage string) {
f.VarP(newUintValue(value, p), name, shorthand, usage)
}
@@ -59,7 +59,7 @@
CommandLine.VarP(newUintValue(value, p), name, "", usage)
}
-// Like UintVar, but accepts a shorthand letter that can be used after a single dash.
+// UintVarP is like UintVar, but accepts a shorthand letter that can be used after a single dash.
func UintVarP(p *uint, name, shorthand string, value uint, usage string) {
CommandLine.VarP(newUintValue(value, p), name, shorthand, usage)
}
@@ -72,7 +72,7 @@
return p
}
-// Like Uint, but accepts a shorthand letter that can be used after a single dash.
+// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) UintP(name, shorthand string, value uint, usage string) *uint {
p := new(uint)
f.UintVarP(p, name, shorthand, value, usage)
@@ -85,7 +85,7 @@
return CommandLine.UintP(name, "", value, usage)
}
-// Like Uint, but accepts a shorthand letter that can be used after a single dash.
+// UintP is like Uint, but accepts a shorthand letter that can be used after a single dash.
func UintP(name, shorthand string, value uint, usage string) *uint {
return CommandLine.UintP(name, shorthand, value, usage)
}
diff --git a/uint16.go b/uint16.go
index 1cdc3df..5c96c19 100644
--- a/uint16.go
+++ b/uint16.go
@@ -46,7 +46,7 @@
f.VarP(newUint16Value(value, p), name, "", usage)
}
-// Like Uint16Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) {
f.VarP(newUint16Value(value, p), name, shorthand, usage)
}
@@ -57,7 +57,7 @@
CommandLine.VarP(newUint16Value(value, p), name, "", usage)
}
-// Like Uint16Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint16VarP is like Uint16Var, but accepts a shorthand letter that can be used after a single dash.
func Uint16VarP(p *uint16, name, shorthand string, value uint16, usage string) {
CommandLine.VarP(newUint16Value(value, p), name, shorthand, usage)
}
@@ -70,7 +70,7 @@
return p
}
-// Like Uint16, but accepts a shorthand letter that can be used after a single dash.
+// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint16P(name, shorthand string, value uint16, usage string) *uint16 {
p := new(uint16)
f.Uint16VarP(p, name, shorthand, value, usage)
@@ -83,7 +83,7 @@
return CommandLine.Uint16P(name, "", value, usage)
}
-// Like Uint16, but accepts a shorthand letter that can be used after a single dash.
+// Uint16P is like Uint16, but accepts a shorthand letter that can be used after a single dash.
func Uint16P(name, shorthand string, value uint16, usage string) *uint16 {
return CommandLine.Uint16P(name, shorthand, value, usage)
}
diff --git a/uint32.go b/uint32.go
index 1326e4a..294fcaa 100644
--- a/uint32.go
+++ b/uint32.go
@@ -46,7 +46,7 @@
f.VarP(newUint32Value(value, p), name, "", usage)
}
-// Like Uint32Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) {
f.VarP(newUint32Value(value, p), name, shorthand, usage)
}
@@ -57,7 +57,7 @@
CommandLine.VarP(newUint32Value(value, p), name, "", usage)
}
-// Like Uint32Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint32VarP is like Uint32Var, but accepts a shorthand letter that can be used after a single dash.
func Uint32VarP(p *uint32, name, shorthand string, value uint32, usage string) {
CommandLine.VarP(newUint32Value(value, p), name, shorthand, usage)
}
@@ -70,7 +70,7 @@
return p
}
-// Like Uint32, but accepts a shorthand letter that can be used after a single dash.
+// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint32P(name, shorthand string, value uint32, usage string) *uint32 {
p := new(uint32)
f.Uint32VarP(p, name, shorthand, value, usage)
@@ -83,7 +83,7 @@
return CommandLine.Uint32P(name, "", value, usage)
}
-// Like Uint32, but accepts a shorthand letter that can be used after a single dash.
+// Uint32P is like Uint32, but accepts a shorthand letter that can be used after a single dash.
func Uint32P(name, shorthand string, value uint32, usage string) *uint32 {
return CommandLine.Uint32P(name, shorthand, value, usage)
}
diff --git a/uint64.go b/uint64.go
index 6788bbf..c681885 100644
--- a/uint64.go
+++ b/uint64.go
@@ -48,7 +48,7 @@
f.VarP(newUint64Value(value, p), name, "", usage)
}
-// Like Uint64Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) {
f.VarP(newUint64Value(value, p), name, shorthand, usage)
}
@@ -59,7 +59,7 @@
CommandLine.VarP(newUint64Value(value, p), name, "", usage)
}
-// Like Uint64Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint64VarP is like Uint64Var, but accepts a shorthand letter that can be used after a single dash.
func Uint64VarP(p *uint64, name, shorthand string, value uint64, usage string) {
CommandLine.VarP(newUint64Value(value, p), name, shorthand, usage)
}
@@ -72,7 +72,7 @@
return p
}
-// Like Uint64, but accepts a shorthand letter that can be used after a single dash.
+// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint64P(name, shorthand string, value uint64, usage string) *uint64 {
p := new(uint64)
f.Uint64VarP(p, name, shorthand, value, usage)
@@ -85,7 +85,7 @@
return CommandLine.Uint64P(name, "", value, usage)
}
-// Like Uint64, but accepts a shorthand letter that can be used after a single dash.
+// Uint64P is like Uint64, but accepts a shorthand letter that can be used after a single dash.
func Uint64P(name, shorthand string, value uint64, usage string) *uint64 {
return CommandLine.Uint64P(name, shorthand, value, usage)
}
diff --git a/uint8.go b/uint8.go
index 560c569..26db418 100644
--- a/uint8.go
+++ b/uint8.go
@@ -48,7 +48,7 @@
f.VarP(newUint8Value(value, p), name, "", usage)
}
-// Like Uint8Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) {
f.VarP(newUint8Value(value, p), name, shorthand, usage)
}
@@ -59,7 +59,7 @@
CommandLine.VarP(newUint8Value(value, p), name, "", usage)
}
-// Like Uint8Var, but accepts a shorthand letter that can be used after a single dash.
+// Uint8VarP is like Uint8Var, but accepts a shorthand letter that can be used after a single dash.
func Uint8VarP(p *uint8, name, shorthand string, value uint8, usage string) {
CommandLine.VarP(newUint8Value(value, p), name, shorthand, usage)
}
@@ -72,7 +72,7 @@
return p
}
-// Like Uint8, but accepts a shorthand letter that can be used after a single dash.
+// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash.
func (f *FlagSet) Uint8P(name, shorthand string, value uint8, usage string) *uint8 {
p := new(uint8)
f.Uint8VarP(p, name, shorthand, value, usage)
@@ -85,7 +85,7 @@
return CommandLine.Uint8P(name, "", value, usage)
}
-// Like Uint8, but accepts a shorthand letter that can be used after a single dash.
+// Uint8P is like Uint8, but accepts a shorthand letter that can be used after a single dash.
func Uint8P(name, shorthand string, value uint8, usage string) *uint8 {
return CommandLine.Uint8P(name, shorthand, value, usage)
}
