func Flags(flagSet *flag.FlagSet, prefix string, includeParallelFlags bool) { prefix = processPrefix(prefix) flagSet.Int64Var(&(GinkgoConfig.RandomSeed), prefix+"seed", time.Now().Unix(), "The seed used to randomize the spec suite.") flagSet.BoolVar(&(GinkgoConfig.RandomizeAllSpecs), prefix+"randomizeAllSpecs", false, "If set, ginkgo will randomize all specs together. By default, ginkgo only randomizes the top level Describe/Context groups.") flagSet.BoolVar(&(GinkgoConfig.SkipMeasurements), prefix+"skipMeasurements", false, "If set, ginkgo will skip any measurement specs.") flagSet.BoolVar(&(GinkgoConfig.FailOnPending), prefix+"failOnPending", false, "If set, ginkgo will mark the test suite as failed if any specs are pending.") flagSet.BoolVar(&(GinkgoConfig.FailFast), prefix+"failFast", false, "If set, ginkgo will stop running a test suite after a failure occurs.") flagSet.BoolVar(&(GinkgoConfig.DryRun), prefix+"dryRun", false, "If set, ginkgo will walk the test hierarchy without actually running anything. Best paired with -v.") flagSet.StringVar(&(GinkgoConfig.FocusString), prefix+"focus", "", "If set, ginkgo will only run specs that match this regular expression.") flagSet.StringVar(&(GinkgoConfig.SkipString), prefix+"skip", "", "If set, ginkgo will only run specs that do not match this regular expression.") flagSet.BoolVar(&(GinkgoConfig.EmitSpecProgress), prefix+"progress", false, "If set, ginkgo will emit progress information as each spec runs to the GinkgoWriter.") if includeParallelFlags { flagSet.IntVar(&(GinkgoConfig.ParallelNode), prefix+"parallel.node", 1, "This worker node's (one-indexed) node number. For running specs in parallel.") flagSet.IntVar(&(GinkgoConfig.ParallelTotal), prefix+"parallel.total", 1, "The total number of worker nodes. For running specs in parallel.") flagSet.StringVar(&(GinkgoConfig.SyncHost), prefix+"parallel.synchost", "", "The address for the server that will synchronize the running nodes.") flagSet.StringVar(&(GinkgoConfig.StreamHost), prefix+"parallel.streamhost", "", "The address for the server that the running nodes should stream data to.") } flagSet.BoolVar(&(DefaultReporterConfig.NoColor), prefix+"noColor", false, "If set, suppress color output in default reporter.") flagSet.Float64Var(&(DefaultReporterConfig.SlowSpecThreshold), prefix+"slowSpecThreshold", 5.0, "(in seconds) Specs that take longer to run than this threshold are flagged as slow by the default reporter (default: 5 seconds).") flagSet.BoolVar(&(DefaultReporterConfig.NoisyPendings), prefix+"noisyPendings", true, "If set, default reporter will shout about pending tests.") flagSet.BoolVar(&(DefaultReporterConfig.Verbose), prefix+"v", false, "If set, default reporter print out all specs as they begin.") flagSet.BoolVar(&(DefaultReporterConfig.Succinct), prefix+"succinct", false, "If set, default reporter prints out a very succinct report") flagSet.BoolVar(&(DefaultReporterConfig.FullTrace), prefix+"trace", false, "If set, default reporter prints out the full stack trace when a failure occurs") }
func (s *ResourceConfigSpecFlag) Register(f *flag.FlagSet) { opts := []struct { name string units string *types.ResourceAllocationInfo }{ {"CPU", "MHz", &s.CpuAllocation}, {"Memory", "MB", &s.MemoryAllocation}, } for _, opt := range opts { prefix := strings.ToLower(opt.name)[:3] shares := (*sharesInfo)(opt.Shares) expandableReservation := false if v := opt.ExpandableReservation; v != nil { expandableReservation = *v } // Initialize bool pointer opt.ExpandableReservation = types.NewBool(false) f.Int64Var(&opt.Limit, prefix+".limit", 0, opt.name+" limit in "+opt.units) f.Int64Var(&opt.Reservation, prefix+".reservation", 0, opt.name+" reservation in "+opt.units) f.BoolVar(opt.ExpandableReservation, prefix+".expandable", expandableReservation, opt.name+" expandable reservation") f.Var(shares, prefix+".shares", opt.name+" shares level or number") } }
// ApplyWithError populates the flag given the flag set and environment func (f Int64Flag) ApplyWithError(set *flag.FlagSet) error { if f.EnvVar != "" { for _, envVar := range strings.Split(f.EnvVar, ",") { envVar = strings.TrimSpace(envVar) if envVal, ok := syscall.Getenv(envVar); ok { envValInt, err := strconv.ParseInt(envVal, 0, 64) if err != nil { return fmt.Errorf("could not parse %s as int value for flag %s: %s", envVal, f.Name, err) } f.Value = envValInt break } } } eachName(f.Name, func(name string) { if f.Destination != nil { set.Int64Var(f.Destination, name, f.Value, f.Usage) return } set.Int64(name, f.Value, f.Usage) }) return nil }
func (cmd *change) Register(f *flag.FlagSet) { f.Int64Var(&cmd.MemoryMB, "m", 0, "Size in MB of memory") f.IntVar(&cmd.NumCPUs, "c", 0, "Number of CPUs") f.StringVar(&cmd.GuestId, "g", "", "Guest OS") f.StringVar(&cmd.Name, "name", "", "Display name") f.Var(&cmd.extraConfig, "e", "ExtraConfig. <key>=<value>") }
func (cmd *tail) Register(ctx context.Context, f *flag.FlagSet) { cmd.DatastoreFlag, ctx = flags.NewDatastoreFlag(ctx) cmd.DatastoreFlag.Register(ctx, f) f.Int64Var(&cmd.count, "c", -1, "Output the last NUM bytes") f.IntVar(&cmd.lines, "n", 10, "Output the last NUM lines") f.BoolVar(&cmd.follow, "f", false, "Output appended data as the file grows") }
func (cmd *boot) Register(f *flag.FlagSet) { f.Int64Var(&cmd.BootDelay, "delay", 0, "Delay in ms before starting the boot sequence") f.StringVar(&cmd.order, "order", "", "Boot device order") f.Int64Var(&cmd.BootRetryDelay, "retry-delay", 0, "Delay in ms before a boot retry") cmd.BootRetryEnabled = types.NewBool(false) f.BoolVar(cmd.BootRetryEnabled, "retry", false, "If true, retry boot after retry-delay") cmd.EnterBIOSSetup = types.NewBool(false) f.BoolVar(cmd.EnterBIOSSetup, "setup", false, "If true, enter BIOS setup on next boot") }
func (cmd *change) Register(ctx context.Context, f *flag.FlagSet) { cmd.VirtualMachineFlag, ctx = flags.NewVirtualMachineFlag(ctx) cmd.VirtualMachineFlag.Register(ctx, f) f.Int64Var(&cmd.MemoryMB, "m", 0, "Size in MB of memory") f.Var(flags.NewInt32(&cmd.NumCPUs), "c", "Number of CPUs") f.StringVar(&cmd.GuestId, "g", "", "Guest OS") f.StringVar(&cmd.Name, "name", "", "Display name") f.Var(&cmd.extraConfig, "e", "ExtraConfig. <key>=<value>") f.Var(flags.NewOptionalBool(&cmd.NestedHVEnabled), "nested-hv-enabled", "Enable nested hardware-assisted virtualization") }
// registerFlags defines all cfssl command flags and associates their values with variables. func registerFlags(c *Config, f *flag.FlagSet) { f.StringVar(&c.Hostname, "hostname", "", "Hostname for the cert, could be a comma-separated hostname list") f.StringVar(&c.CertFile, "cert", "", "Client certificate that contains the public key") f.StringVar(&c.CSRFile, "csr", "", "Certificate signature request file for new public key") f.StringVar(&c.CAFile, "ca", "", "CA used to sign the new certificate") f.StringVar(&c.CAKeyFile, "ca-key", "", "CA private key") f.StringVar(&c.TLSCertFile, "tls-cert", "", "Other endpoint CA to set up TLS protocol") f.StringVar(&c.TLSKeyFile, "tls-key", "", "Other endpoint CA private key") f.StringVar(&c.KeyFile, "key", "", "private key for the certificate") f.StringVar(&c.IntermediatesFile, "intermediates", "", "intermediate certs") f.StringVar(&c.CABundleFile, "ca-bundle", "", "path to root certificate store") f.StringVar(&c.IntBundleFile, "int-bundle", "", "path to intermediate certificate store") f.StringVar(&c.Address, "address", "127.0.0.1", "Address to bind") f.IntVar(&c.Port, "port", 8888, "Port to bind") f.StringVar(&c.ConfigFile, "config", "", "path to configuration file") f.StringVar(&c.Profile, "profile", "", "signing profile to use") f.BoolVar(&c.IsCA, "initca", false, "initialise new CA") f.BoolVar(&c.RenewCA, "renewca", false, "re-generate a CA certificate from existing CA certificate/key") f.StringVar(&c.IntDir, "int-dir", "", "specify intermediates directory") f.StringVar(&c.Flavor, "flavor", "ubiquitous", "Bundle Flavor: ubiquitous, optimal and force.") f.StringVar(&c.Metadata, "metadata", "", "Metadata file for root certificate presence. The content of the file is a json dictionary (k,v): each key k is SHA-1 digest of a root certificate while value v is a list of key store filenames.") f.StringVar(&c.Domain, "domain", "", "remote server domain name") f.StringVar(&c.IP, "ip", "", "remote server ip") f.StringVar(&c.Remote, "remote", "", "remote CFSSL server") f.StringVar(&c.Label, "label", "", "key label to use in remote CFSSL server") f.StringVar(&c.AuthKey, "authkey", "", "key to authenticate requests to remote CFSSL server") f.StringVar(&c.ResponderFile, "responder", "", "Certificate for OCSP responder") f.StringVar(&c.ResponderKeyFile, "responder-key", "", "private key for OCSP responder certificate") f.StringVar(&c.Status, "status", "good", "Status of the certificate: good, revoked, unknown") f.IntVar(&c.Reason, "reason", 0, "Reason code for revocation") f.StringVar(&c.RevokedAt, "revoked-at", "now", "Date of revocation (YYYY-MM-DD)") f.Int64Var(&c.Interval, "interval", int64(4*helpers.OneDay), "Interval between OCSP updates, in seconds (default: 4 days)") f.BoolVar(&c.List, "list", false, "list possible scanners") f.StringVar(&c.Family, "family", "", "scanner family regular expression") f.StringVar(&c.Scanner, "scanner", "", "scanner regular expression") f.DurationVar(&c.Timeout, "timeout", 5*time.Minute, "duration (ns, us, ms, s, m, h) to scan each host before timing out") f.StringVar(&c.Responses, "responses", "", "file to load OCSP responses from") f.StringVar(&c.Path, "path", "/", "Path on which the server will listen") f.StringVar(&c.Password, "password", "0", "Password for accessing PKCS #12 data passed to bundler") f.StringVar(&c.Usage, "usage", "", "usage of private key") f.StringVar(&c.PGPPrivate, "pgp-private", "", "file to load a PGP Private key decryption.") if pkcs11.Enabled { f.StringVar(&c.Module, "pkcs11-module", "", "PKCS #11 module") f.StringVar(&c.Token, "pkcs11-token", "", "PKCS #11 token") f.StringVar(&c.PIN, "pkcs11-pin", os.Getenv("USER_PIN"), "PKCS #11 user PIN") f.StringVar(&c.PKCS11Label, "pkcs11-label", "", "PKCS #11 label") } }
// registerFlagStruct parse struct field, and register with flag set func registerFlagStruct(i interface{}, fs *flag.FlagSet) error { if fs.Parsed() { return ErrFlagParsed } sf := structFields(i) for _, fd := range sf { field := fd.field flagName := fd.tag.name flagUsage := fd.tag.usage fieldPtr := unsafe.Pointer(fd.value.UnsafeAddr()) switch field.Type.Kind() { case reflect.Int: fs.IntVar((*int)(fieldPtr), flagName, fd.tag.intValue(), flagUsage) case reflect.Int64: fs.Int64Var((*int64)(fieldPtr), flagName, fd.tag.int64Value(), flagUsage) case reflect.Uint: fs.UintVar((*uint)(fieldPtr), flagName, fd.tag.uintValue(), flagUsage) case reflect.Uint64: fs.Uint64Var((*uint64)(fieldPtr), flagName, fd.tag.uint64Value(), flagUsage) case reflect.String: fs.StringVar((*string)(fieldPtr), flagName, fd.tag.stringValue(), flagUsage) case reflect.Bool: fs.BoolVar((*bool)(fieldPtr), flagName, fd.tag.boolValue(), flagUsage) case reflect.Float64: fs.Float64Var((*float64)(fieldPtr), flagName, fd.tag.float64Value(), flagUsage) default: if !reflect.PtrTo(field.Type).Implements(flagValueType) { return ErrUnsupportType } fieldValue := reflect.NewAt(field.Type, fieldPtr) switch value := fieldValue.Interface().(type) { case flag.Value: fs.Var(value, flagName, flagUsage) } } } return nil }
func (s *ResourceConfigSpecFlag) Register(ctx context.Context, f *flag.FlagSet) { opts := []struct { name string units string types.BaseResourceAllocationInfo }{ {"CPU", "MHz", s.CpuAllocation}, {"Memory", "MB", s.MemoryAllocation}, } for _, opt := range opts { prefix := strings.ToLower(opt.name)[:3] ra := opt.GetResourceAllocationInfo() shares := (*sharesInfo)(ra.Shares) f.Int64Var(&ra.Limit, prefix+".limit", 0, opt.name+" limit in "+opt.units) f.Int64Var(&ra.Reservation, prefix+".reservation", 0, opt.name+" reservation in "+opt.units) f.Var(flags.NewOptionalBool(&ra.ExpandableReservation), prefix+".expandable", opt.name+" expandable reservation") f.Var(shares, prefix+".shares", opt.name+" shares level or number") } }
// Apply populates the flag given the flag set and environment func (f Int64Flag) Apply(set *flag.FlagSet) { if f.EnvVar != "" { for _, envVar := range strings.Split(f.EnvVar, ",") { envVar = strings.TrimSpace(envVar) if envVal := os.Getenv(envVar); envVal != "" { envValInt, err := strconv.ParseInt(envVal, 0, 64) if err == nil { f.Value = envValInt break } } } } eachName(f.Name, func(name string) { if f.Destination != nil { set.Int64Var(f.Destination, name, f.Value, f.Usage) return } set.Int64(name, f.Value, f.Usage) }) }
func addFieldFlag(field reflect.StructField, value reflect.Value, fs *flag.FlagSet) { name, usage := getFieldNameUsage(field) ptr := unsafe.Pointer(value.UnsafeAddr()) switch field.Type.Kind() { case reflect.Bool: fs.BoolVar((*bool)(ptr), name, *(*bool)(ptr), usage) case reflect.Float64: fs.Float64Var((*float64)(ptr), name, *(*float64)(ptr), usage) case reflect.Int64: fs.Int64Var((*int64)(ptr), name, *(*int64)(ptr), usage) case reflect.Int: fs.IntVar((*int)(ptr), name, *(*int)(ptr), usage) case reflect.String: fs.StringVar((*string)(ptr), name, *(*string)(ptr), usage) case reflect.Uint64: fs.Uint64Var((*uint64)(ptr), name, *(*uint64)(ptr), usage) case reflect.Uint: fs.UintVar((*uint)(ptr), name, *(*uint)(ptr), usage) default: panic(fmt.Sprintf("unsupported type: %v", field.Type)) } }
// registerFlags defines all cfssl command flags and associates their values with variables. func registerFlags(c *Config, f *flag.FlagSet) { f.StringVar(&c.Hostname, "hostname", "", "Hostname for the cert, could be a comma-separated hostname list") f.StringVar(&c.CertFile, "cert", "", "Client certificate that contains the public key") f.StringVar(&c.CSRFile, "csr", "", "Certificate signature request file for new public key") f.StringVar(&c.CAFile, "ca", "ca.pem", "CA used to sign the new certificate") f.StringVar(&c.CAKeyFile, "ca-key", "ca-key.pem", "CA private key") f.StringVar(&c.KeyFile, "key", "", "private key for the certificate") f.StringVar(&c.IntermediatesFile, "intermediates", "", "intermediate certs") f.StringVar(&c.CABundleFile, "ca-bundle", "/etc/cfssl/ca-bundle.crt", "Bundle to be used for root certificates pool") f.StringVar(&c.IntBundleFile, "int-bundle", "/etc/cfssl/int-bundle.crt", "Bundle to be used for intermediate certificates pool") f.StringVar(&c.Address, "address", "127.0.0.1", "Address to bind") f.IntVar(&c.Port, "port", 8888, "Port to bind") f.StringVar(&c.ConfigFile, "config", "", "path to configuration file") f.StringVar(&c.Profile, "profile", "", "signing profile to use") f.BoolVar(&c.IsCA, "initca", false, "initialise new CA") f.StringVar(&c.IntDir, "int-dir", "/etc/cfssl/intermediates", "specify intermediates directory") f.StringVar(&c.Flavor, "flavor", "ubiquitous", "Bundle Flavor: ubiquitous, optimal and force.") f.StringVar(&c.Metadata, "metadata", "/etc/cfssl/ca-bundle.crt.metadata", "Metadata file for root certificate presence. The content of the file is a json dictionary (k,v): each key k is SHA-1 digest of a root certificate while value v is a list of key store filenames.") f.StringVar(&c.Domain, "domain", "", "remote server domain name") f.StringVar(&c.IP, "ip", "", "remote server ip") f.StringVar(&c.Remote, "remote", "", "remote CFSSL server") f.StringVar(&c.Label, "label", "", "key label to use in remote CFSSL server") f.StringVar(&c.AuthKey, "authkey", "", "key to authenticate requests to remote CFSSL server") f.StringVar(&c.ResponderFile, "responder", "", "Certificate for OCSP responder") f.StringVar(&c.Status, "status", "good", "Status of the certificate: good, revoked, unknown") f.IntVar(&c.Reason, "reason", 0, "Reason code for revocation") f.StringVar(&c.RevokedAt, "revoked-at", "now", "Date of revocation (YYYY-MM-DD)") f.Int64Var(&c.Interval, "interval", int64(4*helpers.OneDay), "Interval between OCSP updates, in seconds (default: 4 days)") f.BoolVar(&c.List, "list", false, "list possible scanners") f.StringVar(&c.Family, "family", "", "scanner family regular expression") f.StringVar(&c.Scanner, "scanner", "", "scanner regular expression") if pkcs11.Enabled { f.StringVar(&c.Module, "pkcs11-module", "", "PKCS #11 module") f.StringVar(&c.Token, "pkcs11-token", "", "PKCS #11 token") f.StringVar(&c.PIN, "pkcs11-pin", "", "PKCS #11 user PIN") f.StringVar(&c.PKCS11Label, "pkcs11-label", "", "PKCS #11 label") } }
func (flag *FileAttrFlag) Register(ctx context.Context, f *flag.FlagSet) { f.IntVar(&flag.OwnerId, "uid", 0, "User ID") f.IntVar(&flag.GroupId, "gid", 0, "Group ID") f.Int64Var(&flag.Permissions, "perm", 0, "File permissions") }
// Add the flags accepted by run to the supplied flag set, returning the // variables into which the flags will parse. func populateFlagSet(fs *flag.FlagSet) (flags *flagStorage) { flags = new(flagStorage) flags.MountOptions = make(map[string]string) fs.Var( mountpkg.OptionValue(flags.MountOptions), "o", "Additional system-specific mount options. Be careful!") fs.Int64Var( &flags.Uid, "uid", -1, "If non-negative, the UID that owns all inodes. The default is the UID of "+ "the gcsfuse process.") fs.Int64Var( &flags.Gid, "gid", -1, "If non-negative, the GID that owns all inodes. The default is the GID of "+ "the gcsfuse process.") fs.UintVar( &flags.FileMode, "file-mode", 0644, "Permissions bits for files. Default is 0644.") fs.UintVar( &flags.DirMode, "dir-mode", 0755, "Permissions bits for directories. Default is 0755.") fs.StringVar( &flags.TempDir, "temp-dir", "", "The temporary directory in which to store local copies of GCS objects. "+ "If empty, the system default (probably /tmp) will be used.") fs.Int64Var( &flags.TempDirLimit, "temp-dir-bytes", 1<<31, "A desired limit on the number of bytes used in --temp-dir. May be "+ "exceeded for dirty files that have not been flushed or closed.") fs.Uint64Var( &flags.GCSChunkSize, "gcs-chunk-size", 1<<24, "If set to a non-zero value N, split up GCS objects into multiple "+ "chunks of size at most N when reading, and do not read or cache "+ "unnecessary chunks.") fs.BoolVar( &flags.ImplicitDirs, "implicit-dirs", false, "Implicitly define directories based on their content. See "+ "docs/semantics.md.") fs.DurationVar( &flags.StatCacheTTL, "stat-cache-ttl", time.Minute, "How long to cache StatObject results from GCS.") fs.DurationVar( &flags.TypeCacheTTL, "type-cache-ttl", time.Minute, "How long to cache name -> file/dir type mappings in directory inodes.") fs.Float64Var( &flags.OpRateLimitHz, "limit-ops-per-sec", 5.0, "If positive, a limit on the rate at which we send requests to GCS, "+ "measured over a 30-second window.") fs.Float64Var( &flags.EgressBandwidthLimitBytesPerSecond, "limit-bytes-per-sec", -1, "If positive, a limit on the GCS -> gcsfuse bandwidth for reading "+ "objects, measured over a 30-second window.") return }
// Register fields in the given struct that have the tag `flag:"name,desc"`. // Nested structs are supported as long as the field is a struct value field and not pointer to a struct. // Exception to this is the use of StringList which needs to be a pointer. The StringList type implements // the Set and String methods required by the flag package and is dynamically allocated when registering its flag. // See the test case for example. func RegisterFlags(name string, val interface{}, fs *flag.FlagSet) { t := reflect.TypeOf(val).Elem() v := reflect.Indirect(reflect.ValueOf(val)) // the actual value of val for i := 0; i < t.NumField(); i++ { field := t.Field(i) if field.Anonymous && field.Type.Kind() == reflect.Struct { RegisterFlags(name+"."+field.Name, v.Field(i).Addr().Interface(), fs) continue } // See https://golang.org/ref/spec#Uniqueness_of_identifiers exported := field.PkgPath == "" if exported { tag := field.Tag spec := tag.Get("flag") if spec == "" { continue } // Bind the flag based on the tag spec f, d := "", "" p := strings.Split(spec, ",") if len(p) == 1 { // Just one field, use it as description f = fmt.Sprintf("%s.%s", name, strings.ToLower(field.Name)) d = strings.Trim(p[0], " ") } else { // More than one, the first is the name of the flag f = strings.Trim(p[0], " ") d = strings.Trim(p[1], " ") } fv := v.Field(i).Interface() if v.Field(i).CanAddr() { ptr := v.Field(i).Addr().Interface() // The pointer value switch fv := fv.(type) { case bool: fs.BoolVar(ptr.(*bool), f, fv, d) case string: fs.StringVar(ptr.(*string), f, fv, d) case uint: fs.UintVar(ptr.(*uint), f, fv, d) case uint64: fs.Uint64Var(ptr.(*uint64), f, fv, d) case int64: fs.Int64Var(ptr.(*int64), f, fv, d) case int: fs.IntVar(ptr.(*int), f, fv, d) case float64: fs.Float64Var(ptr.(*float64), f, fv, d) case time.Duration: fs.DurationVar(ptr.(*time.Duration), f, fv, d) case []time.Duration: if len(fv) == 0 { // Special case where we allocate an empty list - otherwise it's default. v.Field(i).Set(reflect.ValueOf([]time.Duration{})) } fs.Var(&durationListProxy{list: ptr.(*[]time.Duration)}, f, d) default: // We only register if the field is a concrete vale and not a pointer // since we don't automatically allocate zero value structs to fill the field slot. switch field.Type.Kind() { case reflect.String: fs.Var(&aliasProxy{ fieldType: field.Type, ptr: ptr, fromString: stringFromString, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, }, f, d) case reflect.Bool: fs.Var(&aliasProxy{ fieldType: field.Type, ptr: ptr, fromString: boolFromString, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, }, f, d) case reflect.Float64: fs.Var(&aliasProxy{ fieldType: field.Type, ptr: ptr, fromString: float64FromString, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, }, f, d) case reflect.Int: fs.Var(&aliasProxy{ fieldType: field.Type, ptr: ptr, fromString: intFromString, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, }, f, d) case reflect.Int64: fs.Var(&aliasProxy{ fieldType: field.Type, ptr: ptr, fromString: int64FromString, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, }, f, d) case reflect.Uint: fs.Var(&aliasProxy{ fieldType: field.Type, ptr: ptr, fromString: uintFromString, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, }, f, d) case reflect.Uint64: fs.Var(&aliasProxy{ fieldType: field.Type, ptr: ptr, fromString: uint64FromString, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, }, f, d) case reflect.Struct: RegisterFlags(f, ptr, fs) case reflect.Slice: et := field.Type.Elem() proxy := &sliceProxy{ fieldType: field.Type, elemType: et, slice: ptr, defaults: reflect.ValueOf(fv).Len() > 0, toString: func(v interface{}) string { return fmt.Sprint("%v", v) }, } fs.Var(proxy, f, d) switch { // Checking for string is placed here first because other types are // convertible to string as well. case reflect.TypeOf(string("")).ConvertibleTo(et): proxy.fromString = stringFromString case reflect.TypeOf(bool(true)).ConvertibleTo(et): proxy.fromString = boolFromString case reflect.TypeOf(float64(1.)).ConvertibleTo(et): proxy.fromString = float64FromString case reflect.TypeOf(int(1)).ConvertibleTo(et): proxy.fromString = intFromString case reflect.TypeOf(int64(1)).ConvertibleTo(et): proxy.fromString = int64FromString case reflect.TypeOf(uint(1)).ConvertibleTo(et): proxy.fromString = uintFromString case reflect.TypeOf(uint64(1)).ConvertibleTo(et): proxy.fromString = uint64FromString case reflect.TypeOf(time.Second).AssignableTo(et): proxy.fromString = durationFromString } } } } } } }