flag

type ColonSeparatedMultimapStringString ¶

type ColonSeparatedMultimapStringString struct {
	Multimap *map[string][]string
	// contains filtered or unexported fields
}

ColonSeparatedMultimapStringString supports setting a map[string][]string from an encoding that separates keys from values with ':' and separates key-value pairs with ','. A key can be repeated multiple times, in which case the values are appended to a slice of strings associated with that key. Items in the list associated with a given key will appear in the order provided. For example: `a:hello,b:again,c:world,b:beautiful` results in `{"a": ["hello"], "b": ["again", "beautiful"], "c": ["world"]}` The first call to Set will clear the map before adding entries; subsequent calls will simply append to the map. This makes it possible to override default values with a command-line option rather than appending to defaults, while still allowing the distribution of key-value pairs across multiple flag invocations. For example: `--flag "a:hello" --flag "b:again" --flag "b:beautiful" --flag "c:world"` results in `{"a": ["hello"], "b": ["again", "beautiful"], "c": ["world"]}`

func NewColonSeparatedMultimapStringString(m *map[string][]string) *ColonSeparatedMultimapStringString

func (m *ColonSeparatedMultimapStringString) Empty() bool

func (m *ColonSeparatedMultimapStringString) Set(value string) error

func (m *ColonSeparatedMultimapStringString) String() string

func (m *ColonSeparatedMultimapStringString) Type() string

type ConfigurationMap ¶

type ConfigurationMap map[string]string

func (m *ConfigurationMap) Set(value string) error

func (m *ConfigurationMap) String() string

func (*ConfigurationMap) Type() string

type LangleSeparatedMapStringString ¶

type LangleSeparatedMapStringString struct {
	Map *map[string]string
	// contains filtered or unexported fields
}

LangleSeparatedMapStringString can be set from the command line with the format `--flag "string<string"`. Multiple comma-separated key-value pairs in a single invocation are supported. For example: `--flag "a<foo,b<bar"`. Multiple flag invocations are supported. For example: `--flag "a<foo" --flag "b<foo"`.

func NewLangleSeparatedMapStringString(m *map[string]string) *LangleSeparatedMapStringString

func (m *LangleSeparatedMapStringString) Empty() bool

func (m *LangleSeparatedMapStringString) Set(value string) error

func (m *LangleSeparatedMapStringString) String() string

func (*LangleSeparatedMapStringString) Type() string

type MapStringBool ¶

type MapStringBool struct {
	Map *map[string]bool
	// contains filtered or unexported fields
}

MapStringBool can be set from the command line with the format `--flag "string=bool"`. Multiple comma-separated key-value pairs in a single invocation are supported. For example: `--flag "a=true,b=false"`. Multiple flag invocations are supported. For example: `--flag "a=true" --flag "b=false"`.

func NewMapStringBool(m *map[string]bool) *MapStringBool

func (m *MapStringBool) Empty() bool

func (m *MapStringBool) Set(value string) error

func (m *MapStringBool) String() string

func (*MapStringBool) Type() string

type MapStringString ¶

type MapStringString struct {
	Map *map[string]string

	NoSplit bool
	// contains filtered or unexported fields
}

MapStringString can be set from the command line with the format `--flag "string=string"`. Multiple flag invocations are supported. For example: `--flag "a=foo" --flag "b=bar"`. If this is desired to be the only type invocation `NoSplit` should be set to true. Multiple comma-separated key-value pairs in a single invocation are supported if `NoSplit` is set to false. For example: `--flag "a=foo,b=bar"`.

func NewMapStringString(m *map[string]string) *MapStringString

func NewMapStringStringNoSplit(m *map[string]string) *MapStringString

func (m *MapStringString) Empty() bool

func (m *MapStringString) Set(value string) error

func (m *MapStringString) String() string

func (*MapStringString) Type() string

type NamedCertKey ¶

type NamedCertKey struct {
	Names             []string
	CertFile, KeyFile string
}

NamedCertKey is a flag value parsing "certfile,keyfile" and "certfile,keyfile:name,name,name".

func (nkc *NamedCertKey) Set(value string) error

func (nkc *NamedCertKey) String() string

func (*NamedCertKey) Type() string

type NamedCertKeyArray ¶

type NamedCertKeyArray struct {
	// contains filtered or unexported fields
}

NamedCertKeyArray is a flag value parsing NamedCertKeys, each passed with its own flag instance (in contrast to comma separated slices).

func NewNamedCertKeyArray(p *[]NamedCertKey) *NamedCertKeyArray

func (a *NamedCertKeyArray) Set(val string) error

func (a *NamedCertKeyArray) String() string

func (a *NamedCertKeyArray) Type() string

type NamedFlagSets ¶

type NamedFlagSets struct {
	// Order is an ordered list of flag set names.
	Order []string
	// FlagSets stores the flag sets by name.
	FlagSets map[string]*pflag.FlagSet
	// NormalizeNameFunc is the normalize function which used to initialize FlagSets created by NamedFlagSets.
	NormalizeNameFunc func(f *pflag.FlagSet, name string) pflag.NormalizedName
}

NamedFlagSets stores named flag sets in the order of calling FlagSet.

func (nfs *NamedFlagSets) FlagSet(name string) *pflag.FlagSet

type NoOp ¶

type NoOp struct{}

NoOp implements goflag.Value and plfag.Value, but has a noop Set implementation

func (NoOp) Set(val string) error

func (NoOp) String() string

func (NoOp) Type() string

type OmitEmpty ¶

type OmitEmpty interface {
	Empty() bool
}

OmitEmpty is an interface for flags to report whether their underlying value is "empty." If a flag implements OmitEmpty and returns true for a call to Empty(), it is assumed that flag may be omitted from the command line.

type StringFlag ¶

type StringFlag struct {
	// contains filtered or unexported fields
}

StringFlag is a string flag compatible with flags and pflags that keeps track of whether it had a value supplied or not.

func NewStringFlag(defaultVal string) StringFlag

func (f *StringFlag) Default(value string)

func (f StringFlag) Provided() bool

func (f *StringFlag) Set(value string) error

func (f StringFlag) String() string

func (f *StringFlag) Type() string

func (f StringFlag) Value() string

type StringSlice ¶ added in v0.21.0

type StringSlice struct {
	// contains filtered or unexported fields
}

StringSlice implements goflag.Value and plfag.Value, and allows set to be invoked repeatedly to accumulate values.

func NewStringSlice(s *[]string) *StringSlice

func (s *StringSlice) Set(val string) error

func (s *StringSlice) String() string

func (StringSlice) Type() string

type Tristate ¶

type Tristate int

Tristate is a flag compatible with flags and pflags that keeps track of whether it had a value supplied or not.

const (
	Unset Tristate = iota // 0
	True
	False
)

func (f *Tristate) Default(value bool)

func (f Tristate) Provided() bool

func (f *Tristate) Set(value string) error

func (f Tristate) String() string

func (f *Tristate) Type() string

func (f Tristate) Value() bool