Generate flag type lookup funcs

flag_generated.go

@@ -1,6 +1,10 @@
 package cli
 
-import "time"
+import (
+	"flag"
+	"strconv"
+	"time"
+)
 
 // WARNING: This file is generated!
 
@@ -39,6 +43,18 @@ func (c *Context) GlobalBool(name string) bool {
 	return false
 }
 
+func lookupBool(name string, set *flag.FlagSet) bool {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseBool(f.Value.String())
+		if err != nil {
+			return false
+		}
+		return parsed
+	}
+	return false
+}
+
 // BoolTFlag is a flag with type bool that is true by default
 type BoolTFlag struct {
 	Name        string
@@ -74,6 +90,18 @@ func (c *Context) GlobalBoolT(name string) bool {
 	return false
 }
 
+func lookupBoolT(name string, set *flag.FlagSet) bool {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseBool(f.Value.String())
+		if err != nil {
+			return false
+		}
+		return parsed
+	}
+	return false
+}
+
 // DurationFlag is a flag with type time.Duration (see https://golang.org/pkg/time/#ParseDuration)
 type DurationFlag struct {
 	Name        string
@@ -110,6 +138,18 @@ func (c *Context) GlobalDuration(name string) time.Duration {
 	return 0
 }
 
+func lookupDuration(name string, set *flag.FlagSet) time.Duration {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := time.ParseDuration(f.Value.String())
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
 // Float64Flag is a flag with type float64
 type Float64Flag struct {
 	Name        string
@@ -146,6 +186,18 @@ func (c *Context) GlobalFloat64(name string) float64 {
 	return 0
 }
 
+func lookupFloat64(name string, set *flag.FlagSet) float64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseFloat(f.Value.String(), 64)
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
 // GenericFlag is a flag with type Generic
 type GenericFlag struct {
 	Name   string
@@ -181,6 +233,18 @@ func (c *Context) GlobalGeneric(name string) interface{} {
 	return nil
 }
 
+func lookupGeneric(name string, set *flag.FlagSet) interface{} {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := f.Value, error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
 // Int64Flag is a flag with type int64
 type Int64Flag struct {
 	Name        string
@@ -217,6 +281,18 @@ func (c *Context) GlobalInt64(name string) int64 {
 	return 0
 }
 
+func lookupInt64(name string, set *flag.FlagSet) int64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
 // IntFlag is a flag with type int
 type IntFlag struct {
 	Name        string
@@ -253,6 +329,18 @@ func (c *Context) GlobalInt(name string) int {
 	return 0
 }
 
+func lookupInt(name string, set *flag.FlagSet) int {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseInt(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return int(parsed)
+	}
+	return 0
+}
+
 // IntSliceFlag is a flag with type *IntSlice
 type IntSliceFlag struct {
 	Name   string
@@ -288,6 +376,18 @@ func (c *Context) GlobalIntSlice(name string) []int {
 	return nil
 }
 
+func lookupIntSlice(name string, set *flag.FlagSet) []int {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := (f.Value.(*IntSlice)).Value(), error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
 // Int64SliceFlag is a flag with type *Int64Slice
 type Int64SliceFlag struct {
 	Name   string
@@ -323,6 +423,18 @@ func (c *Context) GlobalInt64Slice(name string) []int64 {
 	return nil
 }
 
+func lookupInt64Slice(name string, set *flag.FlagSet) []int64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := (f.Value.(*Int64Slice)).Value(), error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
 // StringFlag is a flag with type string
 type StringFlag struct {
 	Name        string
@@ -359,6 +471,18 @@ func (c *Context) GlobalString(name string) string {
 	return ""
 }
 
+func lookupString(name string, set *flag.FlagSet) string {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := f.Value.String(), error(nil)
+		if err != nil {
+			return ""
+		}
+		return parsed
+	}
+	return ""
+}
+
 // StringSliceFlag is a flag with type *StringSlice
 type StringSliceFlag struct {
 	Name   string
@@ -394,6 +518,18 @@ func (c *Context) GlobalStringSlice(name string) []string {
 	return nil
 }
 
+func lookupStringSlice(name string, set *flag.FlagSet) []string {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := (f.Value.(*StringSlice)).Value(), error(nil)
+		if err != nil {
+			return nil
+		}
+		return parsed
+	}
+	return nil
+}
+
 // Uint64Flag is a flag with type uint64
 type Uint64Flag struct {
 	Name        string
@@ -430,6 +566,18 @@ func (c *Context) GlobalUint64(name string) uint64 {
 	return 0
 }
 
+func lookupUint64(name string, set *flag.FlagSet) uint64 {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return parsed
+	}
+	return 0
+}
+
 // UintFlag is a flag with type uint
 type UintFlag struct {
 	Name        string
@@ -465,3 +613,15 @@ func (c *Context) GlobalUint(name string) uint {
 	}
 	return 0
 }
+
+func lookupUint(name string, set *flag.FlagSet) uint {
+	f := set.Lookup(name)
+	if f != nil {
+		parsed, err := strconv.ParseUint(f.Value.String(), 0, 64)
+		if err != nil {
+			return 0
+		}
+		return uint(parsed)
+	}
+	return 0
+}