cli

type AnyMaybeCompActionAndHelperTerminal ¶

type AnyMaybeCompActionAndHelperTerminal = any

AnyMaybeCompActionAndHelperTerminal is an alias of `any` and indicates some component may try to cast the value as a CompAction, HelperTerminal.

type AnyMaybeHelperTerminal ¶

type AnyMaybeHelperTerminal = any

AnyMaybeHelperTerminal is an alias of `any` and indicates some component will try to cast the value as a HelperTerminal.

type ArgErrorHandleFunc ¶

type ArgErrorHandleFunc = func(
	opts *CmdOptions, route Route, args []string, badArgAt int, argErr error,
) error

ArgErrorHandleFunc for args error.

route is the Cmd route from the root to the last known good Cmd.

args are the same args passed to Cmd.ResolveTarget

when badArgAt >= 0, it is where argErr happened, and args[badArgAt] is the bad arg.

Return nil to ignore the error.

type Bool ¶

type Bool = FlagBase[bool, VPBool[bool]]

predefined flag types for scalar values from command line.

type BoolSlice ¶

type BoolSlice = FlagBase[[]bool, VPSlice[bool, VPBool[bool]]]

predefined flag types for slice values from command line.

type BoolSliceV ¶

type BoolSliceV = FlagBaseV[[]bool, VPSlice[bool, VPBool[bool]]]

predefined flag types for slice values from command line.

type BoolV ¶

type BoolV = FlagBaseV[bool, VPBool[bool]]

predefined flag types for scalar values from command line.

type Cmd ¶

type Cmd struct {
	// Pattern is supposed to be a one-line usage pattern of the command.
	//
	// Text before the first space is used for matching args in order to pick
	// this Cmd as sub-command, multiple names can be provided by joining with
	// pipe sign ('|').
	//
	// As of the text after the first space, here is the recommended syntax:
	//
	//	- `[ ]` to define an optional argument.
	//	- `...` to allow multiple values for the previous arg.
	//	- `|` to provide mutually exclusive options.
	//	- `{ }` to define a group of mutually exclusive args.
	//
	// Example (where foo is the command name):
	//
	//	foo|f [-F file | -D dir]... [-f {text|audio}] profile
	//
	// In the above example, `foo` is the command name and `f` is its alias.
	Pattern string

	// BriefUsage introduces the command briefly.
	BriefUsage string

	// Flags are flags accessible from both this Cmd and all its children.
	Flags FlagFinderMaybeIter

	// LocalFlags are flags only accessible from this Cmd.
	//
	// It is preferred to Flags for flag looking up.
	LocalFlags FlagFinderMaybeIter

	// FlagRule enforces certain rule to flags.
	FlagRule Rule

	// PreRun hook, see the type alias definition for parameter details.
	//
	// In Cmd.Exec, it is called from the root Cmd down to the target Cmd
	// before calling Run (even if the target Cmd's Run may be nil).
	PreRun PreRunFunc

	// Run, see the type alias definition for parameter details.
	//
	// In Cmd.Exec, it is called only when the owner Cmd is the target Cmd.
	Run RunFunc

	// PostRun hook, see the type alias definition for parameter details.
	//
	// In Cmd.Exec, it is called from that target Cmd up to the root Cmd after
	// the Run function returned.
	PostRun PostRunFunc

	// Help provides command specific help request handling.
	//
	// If not nil, it is called on help request for this command, otherwise
	// fallback to CmdOptions.HandleHelpRequest.
	Help HelpHandleFunc

	// Completion is the shell completion helper to suggest args for the
	// command.
	Completion CompAction

	// Extra stores application specific custom data.
	Extra AnyMaybeHelperTerminal

	// Children are sub-commands beloning to this Cmd.
	Children []*Cmd

	// State is Cmd's current state.
	State CmdState
}

A Cmd represents a command.

TODO: define Command interface.

package main

import (
	"errors"
	"os"
	"regexp"
	"time"

	"github.com/primecitizens/cli"
)

type Config struct {
	Subject string                `cli:"s|subject,hide,#a simple string flag"`
	Dur     *time.Duration        `cli:"d|duration,value=dur,#example duration flag"`
	Size    uint64                `cli:"size,value=size,def=32G,#size accepting common units"`
	Entries *[]string             `cli:"e|entry,#log entries"`
	Metrics map[time.Duration]int `cli:"m|metric,key=dur,value=sum,#metrics summary"`
	Pattern []*regexp.Regexp      `cli:"p|pattern,value=regexp,def=.*,def=^p,#regexp patterns"`
}

func main() {
	opts := &cli.CmdOptions{
		ParseOptions: &cli.ParseOptions{
			// define custom args can initiate help request.
			HelpArgs: []string{"-?", "why not?"},
		},
		Stderr: os.Stdout, // override stderr to work with golang example test
		// You can provide your own HelpHandleFunc, but here we use the one comes with
		// the library.
		HandleHelpRequest: cli.HandleHelpRequest,
	}

	root := cli.Cmd{
		Pattern:    "example -?",
		BriefUsage: "Just like all other indexers, terminal help also works with the ReflectIndexer",
		Flags: cli.NewReflectIndexer(cli.DefaultReflectVPFactory{}, &Config{
			Subject: "Some default value deduced from flag state",
		}),
	}

	err := root.Exec(opts, "-?")
	if err != nil && !errors.Is(err, cli.ErrHelpHandled{}) {
		panic(err)
	}

}

Output:

example -?

Just like all other indexers, terminal help also works with the ReflectIndexer

Flags:
  -s --subject str          (hidden) a simple string flag (default: Some default value deduced from flag state)
  -d --duration dur         example duration flag
     --size size            size accepting common units (default: 32G)
  -e --entry []str          log entries
  -m --metric map[dur]isum  metrics summary
  -p --pattern []regexp     regexp patterns (default: [.*, ^p])

package main

import (
	"fmt"

	"github.com/primecitizens/cli"
)

func main() {
	var (
		str string

		flagB cli.BoolV
		flagI cli.IntV
		flagS = cli.String{
			Value: &str,
		}
	)

	root := &cli.Cmd{
		Pattern:    "example {print-flag-values|help|completion}",
		BriefUsage: "Using MapIndexer feels the same as a builder (but way more decentralized).",
		Flags: cli.NewMapIndexer().
			Add(&flagB, "bool", "B").
			Add(&flagI, "int", "I").
			Add(&flagS, "string", "S"),
		LocalFlags: nil,
		FlagRule:   cli.AllOf("bool", "int"),
		Completion: cli.CompActionFiles{},
		Children: []*cli.Cmd{
			{
				Pattern: "print-flag-values",
				Run: func(opts *cli.CmdOptions, route cli.Route, posArgs, dashArgs []string) error {
					fmt.Println("bool:", flagB.Value)
					fmt.Println("int:", flagI.Value)
					fmt.Println("string:", str)
					fmt.Println("posArgs:", posArgs)
					fmt.Println("dashArgs:", dashArgs)
					return nil
				},
			},
			(&cli.CompCmdShells{}).Setup("", -1, false),
		},
	}

	err := root.Exec(&cli.CmdOptions{
		HandleArgError:    cli.HandleArgErrorAsHelpRequest,
		HandleHelpRequest: cli.HandleHelpRequest,
	},
		"print-flag-values", "-BI", "10", "--string", "str", "pos1", "--", "dd1",
	)
	if err != nil {
		panic(err)
	}

}

Output:

bool: true
int: 10
string: str
posArgs: [pos1]
dashArgs: [dd1]

package main

import (
	"fmt"
	"regexp"
	"sort"
	"strings"
	"time"

	"github.com/primecitizens/cli"
)

type Config struct {
	Subject string                `cli:"s|subject,hide,#a simple string flag"`
	Dur     *time.Duration        `cli:"d|duration,value=dur,#example duration flag"`
	Size    uint64                `cli:"size,value=size,def=32G,#size accepting common units"`
	Entries *[]string             `cli:"e|entry,#log entries"`
	Metrics map[time.Duration]int `cli:"m|metric,key=dur,value=sum,#metrics summary"`
	Pattern []*regexp.Regexp      `cli:"p|pattern,value=regexp,def=.*,def=^p,#regexp patterns"`
}

func run(opts *cli.CmdOptions, route cli.Route, posArgs, dashArgs []string) error {
	config := route.Root().Extra.(*Config)

	fmt.Println("After", config.Dur.Hours(), "hours,",
		config.Subject, "would have", config.Size, "bytes of data")
	fmt.Println("Some of the entries will be like:")
	fmt.Println(strings.Join(*config.Entries, "\n"))
	fmt.Println("Some of the metrics will be like:")
	var keys []time.Duration
	for k := range config.Metrics {
		keys = append(keys, k)
	}
	sort.Slice(keys, func(i, j int) bool { return keys[i] < keys[j] })
	for _, k := range keys {
		fmt.Println("[metric]", k.String(), "=", config.Metrics[k])
	}
	return nil
}

func main() {
	var cfg Config
	root := cli.Cmd{
		Pattern: "example",
		Flags:   cli.NewReflectIndexer(cli.DefaultReflectVPFactory{}, &cfg),
		Run:     run,
		Extra:   &cfg, // run func will find this
	}

	err := root.Exec(nil,
		"-d", "32.5d", "--subject", "log file", "--size", "10T",
		"-e", "[app] err", "-e", "[app] fatal",
		"-m", "10s=2", "--metric", "10s=5",
	)
	if err != nil {
		panic(err)
	}

}

Output:

After 780 hours, log file would have 10995116277760 bytes of data
Some of the entries will be like:
[app] err
[app] fatal
Some of the metrics will be like:
[metric] 10s = 7

func (c *Cmd) Exec(opts *CmdOptions, args ...string) (err error)

func (c *Cmd) Is(s string) bool

func (c *Cmd) Name() (name string)

func (c *Cmd) ResolveTarget(opts *CmdOptions, args ...string) (
	route Route, posArgs, dashArgs []string, err error,
)

type CmdHelp ¶

type CmdHelp struct {
	// Example lists some typical use cases of the command.
	//
	// DO NOT include prefix like `Example: `
	Example string

	// LongDescription is the detailed description of the command.
	LongDescription string

	// Experimental explains why the command is Experimental.
	//
	// Only use this field to note the reason of being experimental, and
	// DO NOT include prefix like `Experimental: `
	Experimental string

	// Deprecation is the deprecation message of the command.
	//
	// Only use this message to note the reason of deprecation, and
	// DO NOT include prefix like `Deprecated: `
	Deprecation string

	// Changelog may contain upgrade notice of the command.
	//
	// DO NOT include prefix like `Changelog: `
	Changelog string

	// Extra custom data
	Extra any
}

CmdHelp contains commonly used metadata for a cli command.

To produce consistent content, all values SHOULD NOT contain leading or trailling whitespaces.

Hint: use Cmd.Extra to hold *CmdHelp for documentation purpose.

func (m *CmdHelp) HelplnCmdTerminal(out io.Writer, route Route, linePrefix string) (n int, err error)

func (h *CmdHelp) HelplnFlagTerminal(
	out io.Writer, route Route, linePrefix string,
	indent int, flag FlagInfo, groupHasShorthand bool,
) (int, error)

type CmdOptions ¶

type CmdOptions struct {
	ParseOptions *ParseOptions

	// RouteBuf is the buffer for building the Cmd route.
	RouteBuf Route

	// Stdin is the stdin of the cmd.
	//
	// Defaults to nil.
	Stdin io.Reader

	// Stdout is the stdout of the cmd.
	//
	// Defaults to nil.
	Stdout io.Writer

	// Stderr is the stderr of the cmd.
	//
	// Defaults to nil.
	Stderr io.Writer

	// HandleArgError is the function get called to handle errors happened
	// during target resolving.
	HandleArgError ArgErrorHandleFunc

	// HandleHelpRequest is the fallback help request handle func.
	//
	// In a Cmd.Exec call, if both target Cmd.Help func and
	// CmdOptions.HandleHelpRequest are nil, no help will be provided.
	HandleHelpRequest HelpHandleFunc

	// Extra custom data.
	Extra any

	// SkipPostRun skips the Cmd.PostRun when set to true.
	SkipPostRun bool

	// DoNotSetFlags skips setting flag values.
	DoNotSetFlags bool
}

CmdOptions are options for Cmd execution.

func (c *CmdOptions) PickStderr(def ...io.Writer) io.Writer

func (c *CmdOptions) PickStdin(def ...io.Reader) io.Reader

func (c *CmdOptions) PickStdout(def ...io.Writer) io.Writer

type CmdState ¶

type CmdState uint32

const (
	// CmdStateHidden hides the cmd from completion when set.
	CmdStateHidden CmdState = 1 << iota
	// CmdStatePreRunOnce to require the PreRun only gets called once.
	CmdStatePreRunOnce
	CmdStatePreRunCalled

	// CmdStatePostRunOnce to require the PostRun only gets called once.
	CmdStatePostRunOnce
	CmdStatePostRunCalled
)

func (s CmdState) Hidden() bool

func (s CmdState) PostRunCalled() bool

func (s CmdState) PostRunOnce() bool

func (s CmdState) PreRunCalled() bool

func (s CmdState) PreRunOnce() bool

type CompAction ¶

type CompAction interface {
	// Suggest adds possible CompItems according to CompTask.
	Suggest(tsk *CompTask) (added int, state CompState)
}

CompAction defines the interface for a completion action.

type CompActionDirs ¶

type CompActionDirs struct{}

CompActionDirs adds a CompItem to request dir completion.

func (CompActionDirs) Suggest(tsk *CompTask) (int, CompState)

type CompActionDisable ¶

type CompActionDisable struct{}

CompActionDisable marks the CompTask failed, so it can be used to disable the default completion behavior.

func (CompActionDisable) Suggest(tsk *CompTask) (int, CompState)

type CompActionFiles ¶

type CompActionFiles struct{}

CompActionFiles adds a CompItem to request file completion.

func (CompActionFiles) Suggest(tsk *CompTask) (int, CompState)

type CompActionFunc ¶

type CompActionFunc func(tsk *CompTask) (int, CompState)

CompActionFunc wraps a function as Completion implementation.

func (fn CompActionFunc) Suggest(tsk *CompTask) (int, CompState)

type CompActionStatic ¶

type CompActionStatic struct {
	Suggestions []CompItem
	Want, State CompState
}

CompActionStatic adds its predefined suggestions for completion request.

func (s *CompActionStatic) Suggest(tsk *CompTask) (int, CompState)

type CompCmdBash ¶

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

CompCmdBash is a bash completion command.

func (cc *CompCmdBash) Setup(opComplete *Cmd) *Cmd

type CompCmdOpComplete ¶

type CompCmdOpComplete struct {
	// Timeout is the time limit to one completion request.
	Timeout DurationV

	// DebugFile is the file to write debug messages.
	DebugFile StringV

	// At is the position the cursor currently At.
	//
	// for zsh, it should be ($CURRENT - 1).
	// for bash, it should be $cword
	// for pwsh, it should be arg index base on $cursorPosition
	At UintV
	// contains filtered or unexported fields
}

CompCmdOpComplete wraps the `complete` operation sub-command for type CompCmd{Bash, Zsh, Pwsh}.

It prepares the CompTask and invokes its parent Cmd to process the task.

func (cc *CompCmdOpComplete) FindFlag(name string) (Flag, bool)

func (cc *CompCmdOpComplete) NthFlag(i int) (info FlagInfo, ok bool)

func (cc *CompCmdOpComplete) Setup(defaultTimeout time.Duration) *Cmd

func (cc *CompCmdOpComplete) Task() *CompTask

type CompCmdPwsh ¶

type CompCmdPwsh CompCmdBash

CompCmdPwsh is a powershell completion command.

func (cc *CompCmdPwsh) Setup(opComplete *Cmd) *Cmd

type CompCmdShells ¶

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

CompCmdShells is wraps all supported shell completion commands:

• bash {,complete}
• zsh {,complete}
• pwsh {,complete}

To use it, the return value of (&CompCmdShells{}).Setup(...) should be a direct child to your application's root command.

func (cc *CompCmdShells) Setup(name string, defaultTimeout time.Duration, hide bool) *Cmd

type CompCmdZsh ¶

type CompCmdZsh CompCmdBash

CompCmdZsh is a zsh completion command.

func (cc *CompCmdZsh) Setup(opComplete *Cmd) *Cmd

type CompFmt ¶

type CompFmt interface {
	// Format writes one CompItem each line with shell specific character
	// escaping and formatting.
	Format(out io.Writer, finishedTask *CompTask) error
}

CompFmt defines completion result formatter.

type CompFmtBash ¶

type CompFmtBash struct {
	// Cols is supposed to be the $COLUMNS in bash completion.
	Cols int

	// CompType is the type of completion:
	//
	//  - '\t' (9) for normal completion
	//  - '?' (63) for listing completions after successive tabs
	//  - '!' (33) for listing alternatives on partial word completion
	//  - '@' (64) to list completions if the word is not unmodified
	//  - '%' (37) for menu completion
	//  - '*' (42) for insert completion
	//
	// Refs:
	//  - https://www.gnu.org/savannah-checkouts/gnu/bash/manual/bash.html#index-COMP_005fTYPE
	CompType int
}

CompFmtBash implements CompFmt for bash.

It produces two kinds of lines:

• ' <value>' (space prefixed) where <value> contains arguments to bash function _filedir.
• others (without space prefix), as bash-completion COMPREPLY element.

func (fmt *CompFmtBash) EscapeSpaces(out io.Writer, s string, oneline bool) (int, error)

func (fmt *CompFmtBash) Format(out io.Writer, tsk *CompTask) (err error)

type CompFmtPwsh ¶

type CompFmtPwsh struct {
	// Mods is the PowerShell completion mode, possible values are:
	//
	//  - TabCompleteNext (default windows style - on each key press the next option is displayed)
	//  - Complete (works like bash)
	//  - MenuComplete (works like zsh)
	Mode string
}

CompFmtPwsh implements CompFmt for powershell.

It produces two kinds of lines:

• `<value> ;<description>` (note the space and unescaped semi-colon) for creating CompletionResult items.
• `;<argument-spec>` (note the unescaped semi-colon prefix) for filesystem related completion.

func (fmt *CompFmtPwsh) EscapeSpecialChars(out io.Writer, s string, oneline bool) (int, error)

func (fmt *CompFmtPwsh) Format(out io.Writer, tsk *CompTask) (err error)

type CompFmtZsh ¶

type CompFmtZsh struct{}

CompFmtZsh implements CompFmt for zsh.

It produces two kinds of lines:

• `<value>:<description>` for zsh function _describe.
• `:<argument-spec>` (note the colon prefix) for zsh function _arguments, currently only used for filename and dirname completion.

func (CompFmtZsh) EscapeColons(out io.Writer, s string, oneline bool) (int, error)

func (fmt CompFmtZsh) Format(out io.Writer, tsk *CompTask) (err error)

type CompItem ¶

type CompItem struct {
	// Value is the suggested text arg (e.g. foo, --bar).
	//
	// When Kind is one of [Files, Dirs], it is the glob pattern
	Value string

	// Description is the help text of the value.
	Description string

	// Kind marks the completion kind.
	Kind CompKind
}

A CompItem is a completion suggestion.

type CompKind ¶

type CompKind uint8

CompKind gives CompItem type information.

const (
	CompKindText CompKind = iota
	CompKindFlagName
	CompKindFlagValue
	CompKindFiles
	CompKindDirs
)

type CompState ¶

type CompState uint32

CompState used by CompTask to manage completion values.

const (
	// CompStateFailed to NOT use any completion.
	CompStateFailed CompState = 1 << iota

	CompStateDone // to NOT add further CompItems.

	CompStateHasFlagNames
	CompStateHasFlagValues
	CompStateHasSubcmds
	CompStateHasFiles
	CompStateHasDirs

	CompStateOptionNospace
	CompStateOptionNosort
)

func (c CompState) Done() bool

func (c CompState) Failed() bool

func (c CompState) HasDirs() bool

func (c CompState) HasFiles() bool

func (c CompState) HasFlagNames() bool

func (c CompState) HasFlagValues() bool

func (c CompState) HasSubcmds() bool

func (c CompState) OptionNosort() bool

func (c CompState) OptionNospace() bool

type CompTask ¶

type CompTask struct {

	// ExecutablePath is the path to the executable which requested this
	// completion task.
	ExecutablePath string

	// Args are all args present on command-line, including args after the
	// one requested the completion.
	Args []string

	// At is the position of the arg to complete.
	//
	// when At == len(Args), the task is to suggest the next arg.
	// when 0 <= At <= len(Args)-1, the task is to complete the last partial arg.
	// when < len(Args)-1, the task is to complete previous partial arg.
	At int

	// ToComplete is the arg value to be compeleted.
	//
	// When completing a flag value, it is the value part of the arg, which
	// means if command-line input triggering the completion was
	// `--foo=s<tab>` and `foo` can be found in that context, then this field
	// will get `s`.
	ToComplete string

	// Route is the Cmd route up to the arg to complete.
	Route Route

	// PosArgs are all positional args found before the arg to complete.
	//
	// Depending on the position of the arg to complete, the Args field may
	// contain positional args, but this field can get nothing.
	PosArgs []string

	// DashArgs are all args found after the first dash but before the arg
	// to complete.
	//
	// If the arg to complete is before the dash, the Args may contain dash
	// but this field will get nothing.
	DashArgs []string

	// FlagMissingValue is the Flag right before the arg to complete and is
	// missing the value in arg to complete.
	FlagMissingValue Flag
	FlagValuePrefix  string
	// contains filtered or unexported fields
}

CompTask represents a completion tsk.

func (tsk *CompTask) Add(force bool, items ...CompItem) (added int)

func (tsk *CompTask) AddDefault() (added int)

func (tsk *CompTask) AddDirs(force bool, globs ...string) (added int)

func (tsk *CompTask) AddFiles(force bool, globs ...string) (added int)

func (tsk *CompTask) AddFlagNames(force bool, flags FlagIndexer, descr bool) (added int)

func (tsk *CompTask) AddFlagValues(force bool, flag Flag, def string, addDefaults bool) (added int)

func (tsk *CompTask) AddMatched(force bool, items ...CompItem) (added int)

func (tsk *CompTask) AddSubcmds(force bool, cmd *Cmd, descr bool) (added int)

func (tsk *CompTask) Debug(msgs ...string)

func (tsk *CompTask) Done()

func (tsk *CompTask) Fail()

func (tsk *CompTask) Init(root *Cmd, opts *CmdOptions, at int, args ...string)

func (tsk *CompTask) Nth(i int) (CompItem, bool)

func (tsk *CompTask) RawToComplete() string

func (tsk *CompTask) SetDebugOutput(out io.Writer)

func (tsk *CompTask) State() CompState

func (tsk *CompTask) Want() CompState

type DefaultReflectVPFactory ¶

type DefaultReflectVPFactory struct{}

DefaultReflectVPFactory is the ReflectVPFactory implementation referenced from comments of ReflectIndexer.

func (DefaultReflectVPFactory) GetVPReflectFor(fieldType reflect.Type, keyType, valueType string) (vp VP[*reflect.Value], err error)

type Duration ¶

type Duration = FlagBase[time.Duration, VPDuration[time.Duration]]

predefined flag types for scalar values from command line.

type DurationSlice ¶

type DurationSlice = FlagBase[[]time.Duration, VPSlice[time.Duration, VPDuration[time.Duration]]]

predefined flag types for slice values from command line.

type DurationSliceV ¶

type DurationSliceV = FlagBaseV[[]time.Duration, VPSlice[time.Duration, VPDuration[time.Duration]]]

predefined flag types for slice values from command line.

type DurationSum ¶

type DurationSum = FlagBase[time.Duration, VPSum[time.Duration, VPDuration[time.Duration]]]

predefined flag types for sumed scalar values from command line.

type DurationSumV ¶

type DurationSumV = FlagBaseV[time.Duration, VPSum[time.Duration, VPDuration[time.Duration]]]

predefined flag types for sumed scalar values from command line.

type DurationV ¶

type DurationV = FlagBaseV[time.Duration, VPDuration[time.Duration]]

predefined flag types for scalar values from command line.

type ErrAmbiguousArgs ¶

type ErrAmbiguousArgs struct {
	Name  string
	Value string
	At    int
}

ErrAmbiguousArgs caused by an arg (.Value) with hyphen (`-`) prefix, and the arg before it (.Name) is a flag name having implicit value but also accepts it as value.

func (err *ErrAmbiguousArgs) Error() string

type ErrCmdNotRunnable ¶

type ErrCmdNotRunnable struct {
	Name string
}

ErrCmdNotRunnable

func (err *ErrCmdNotRunnable) Error() string

type ErrDuplicateFlag ¶

type ErrDuplicateFlag struct {
	// Name of the flag found duplicate.
	Name string
}

ErrDuplicateFlag is the panic value caused by MapIndexer found duplicate flag registration.

func (err *ErrDuplicateFlag) Error() string

type ErrEmptyRoute ¶

type ErrEmptyRoute struct{}

func (ErrEmptyRoute) Error() string

type ErrFlagSetAtMostOnce ¶

type ErrFlagSetAtMostOnce struct{}

ErrFlagSetAtMostOnce for flags marked once but appeared more than once.

func (ErrFlagSetAtMostOnce) Error() string

type ErrFlagUndefined ¶

type ErrFlagUndefined struct {
	// Name of the missing flag.
	Name string
	// At
	//
	// When >= 0, the error occurred during flag parsing and args[At] is the
	// arg containing the flag.
	//
	// When < 0, just a flag not defined.
	At int
}

ErrFlagUndefined

func (err *ErrFlagUndefined) Error() string

type ErrFlagValueInvalid ¶

type ErrFlagValueInvalid struct {
	// Name of the flag having invalid value.
	Name string

	// Value is the invalid value.
	Value string

	// NameAt is the arg index into the full arg list (`args`)
	//
	// args[NameAt] is the arg containing the flag name.
	NameAt int

	// ValueAt is the arg index into the full arg list (`args`)
	//
	// when >= 0, args[ValueAt] is the arg containing the flag value.
	// otherwise, the invalid value was implied by the flag.
	ValueAt int

	// Reason is the error caused this error.
	Reason error
}

ErrFlagValueInvalid

func (err *ErrFlagValueInvalid) Error() string

type ErrFlagValueMissing ¶

type ErrFlagValueMissing struct {
	// Name is a single flag name without standard hyphen prefix.
	Name string

	// At is the arg index into the full arg list.
	At int
}

ErrFlagValueMissing

func (err *ErrFlagValueMissing) Error() string

type ErrHelpHandled ¶

type ErrHelpHandled struct{}

ErrHelpHandled is used to notify caller the help request has been handled.

func (ErrHelpHandled) Error() string

type ErrHelpPending ¶

type ErrHelpPending struct {
	// HelpArg is the arg value that requested the help handling.
	HelpArg string
	// At is the HelpArg index into the full arg list.
	At int
}

ErrHelpPending for help but no help handle func could be found.

func (err *ErrHelpPending) Error() string

type ErrInvalidValue ¶

type ErrInvalidValue struct {
	// Type is the type or format the Value supposed to be.
	Type string

	// Value is the actual bad value.
	Value string

	// Partial When set to true, means the Value contains a invalid part,
	// and that part is meant to be a Type value.
	Partial bool
}

ErrInvalidValue

func (v *ErrInvalidValue) Error() string

type ErrShorthandOfExplicitFlagInMiddle ¶

type ErrShorthandOfExplicitFlagInMiddle struct {
	Shorthand        string
	ShorthandCluster string
	Value            string
}

ErrShorthandOfExplicitFlagInMiddle caused by a cluster of flag shorthands with explicit value assigning (e.g. -abcdefg=foo), some shorthand in middle rather than the last one requires a explicit value.

func (err *ErrShorthandOfExplicitFlagInMiddle) Error() string

type ErrTimeout ¶

type ErrTimeout struct{}

ErrTimeout

func (ErrTimeout) Error() string

type ErrUnsupportedType ¶

type ErrUnsupportedType struct {
	Type      reflect.Type
	KeyType   string
	ValueType string
}

func (e *ErrUnsupportedType) Error() string

type Flag ¶

type Flag interface {
	// Type returns (typename, true) if there is type information for this
	// flag.
	Type() (string, bool)

	// ImplyValue returns the text implied by the existence of the flag name.
	//
	// return ("", false) to indicate the flag doesn't have implied value.
	ImplyValue() (string, bool)

	// Decode decodes a text argument to the flag value.
	Decode(opts *ParseOptions, name, arg string, set bool) error

	// Extra returns the user defined extra data.
	Extra() AnyMaybeCompActionAndHelperTerminal

	// FlagState returns the state of the flag.
	State() FlagState

	// HasValue returns true if calling PrintValue will write some
	// value.
	HasValue() bool

	// PrintValue writes the text representation of current value of
	// the flag.
	//
	// It MAY panic if HasValue returned false.
	PrintValue(out io.Writer) (int, error)

	// Usage returns the brief usage of the flag.
	Usage() string
}

Flag defines the interface of an entry used by FlagIndexer and ParseFlag.

NOTE: In this package, a Flag's default value is provided by the FlagInfo and will only be assign to Flags inside Cmd.Exec.

func FindFlag[F FlagFinder](flags F, names ...string) (name string, flag Flag, found bool)

type FlagBase ¶

type FlagBase[T any, P VP[*T]] struct {
	// BriefUsage is the help text for terminal user.
	BriefUsage string

	// Ext is the extra custom data for this flag.
	Ext AnyMaybeCompActionAndHelperTerminal

	// Value points to the actual variable to set.
	Value *T

	VP P

	// State_ of the flag.
	State_ FlagState
}

FlagBase holds a pointer to the actual value.

func (f *FlagBase[T, P]) Decode(opts *ParseOptions, name, arg string, set bool) error

func (f *FlagBase[T, P]) Extra() any

func (f *FlagBase[T, P]) HasValue() bool

func (f *FlagBase[T, P]) ImplyValue() (string, bool)

func (f *FlagBase[T, P]) PrintValue(out io.Writer) (int, error)

func (f *FlagBase[T, P]) State() FlagState

func (f *FlagBase[T, P]) Type() (string, bool)

func (f *FlagBase[T, P]) Usage() string

type FlagBaseV ¶

type FlagBaseV[T any, P VP[*T]] struct {
	// BriefUsage is the help text for terminal user.
	BriefUsage string

	// Ext is the extra custom data for this flag.
	Ext AnyMaybeCompActionAndHelperTerminal

	// State_ of the flag.
	State_ FlagState

	// Value of the flag.
	Value T

	VP P
}

FlagBaseV is FlagBase but with value embedded.

func (f *FlagBaseV[T, P]) Decode(opts *ParseOptions, name, arg string, set bool) error

func (f *FlagBaseV[T, P]) Extra() any

func (f *FlagBaseV[T, P]) HasValue() bool

func (f *FlagBaseV[T, P]) ImplyValue() (string, bool)

func (f *FlagBaseV[T, P]) PrintValue(out io.Writer) (int, error)

func (f *FlagBaseV[T, P]) State() FlagState

func (f *FlagBaseV[T, P]) Type() (string, bool)

func (f *FlagBaseV[T, P]) Usage() string

type FlagEmptyV ¶

type FlagEmptyV FlagBaseV[struct{}, VPNop[*struct{}]]

FlagEmptyV is a flag without value.

func (f *FlagEmptyV) Decode(opts *ParseOptions, name, arg string, set bool) error

func (f *FlagEmptyV) Extra() any

func (f *FlagEmptyV) HasValue() bool

func (f *FlagEmptyV) ImplyValue() (string, bool)

func (f *FlagEmptyV) PrintValue(io.Writer) (int, error)

func (f *FlagEmptyV) State() FlagState

func (f *FlagEmptyV) Type() (string, bool)

func (f *FlagEmptyV) Usage() string

type FlagFinder ¶

type FlagFinder interface {
	// FindFlag searches flags known to this FlagFinder by name.
	//
	// The name can be either a full flag name or a flag shorthand, and
	// doesn't contain the POSIX & GNU flag prefix (`-` and `--`).
	FindFlag(name string) (Flag, bool)
}

FlagFinder

type FlagFinderMaybeIter ¶

type FlagFinderMaybeIter = FlagFinder

FlagFinderMaybeIter is an alias of FlagFinder but indicates the implementation may have additional FlagIter support.

type FlagHelp ¶

type FlagHelp struct {
	// Experimental explains why the flag is Experimental.
	//
	// Only use this field to note the reason of being experimental, and
	// DO NOT include prefix like `EXPERIMENTAL: `
	Experimental string

	// Deprecation is the deprecation message of the flag.
	//
	// Only use this field to note the reason of deprecation, and
	// DO NOT include prefix like `DEPRECATED: `
	Deprecation string

	// Changelog may contain upgrade notice of the flag.
	//
	// DO NOT include prefix like `CHANGELOG: `
	Changelog string

	// Completion is the completion action to be called to add suggestions.
	Completion CompAction

	// Extra custom data.
	Extra any
}

FlagHelp defines commonly used flag metadata

Hint: use .Extra of a flag to hold FlagHelp for documentation purpose.

func (h *FlagHelp) HelplnCmdTerminal(out io.Writer, route Route, prefix string) (int, error)

func (h *FlagHelp) HelplnFlagTerminal(
	out io.Writer, route Route, prefix string, indent int, info FlagInfo, groupHasShorthand bool,
) (n int, err error)

func (h *FlagHelp) Suggest(tsk *CompTask) (added int, state CompState)

type FlagIndexer ¶

type FlagIndexer interface {
	FlagFinder
	FlagIter
}

FlagIndexer is the combination of FlagFinder and FlagIter.

type FlagInfo ¶

type FlagInfo struct {
	// Name is the long flag name (the long one).
	Name string
	// Shorthand is the flag shorthand.
	Shorthand string

	// DefaultValue is the default value used for the flag.
	//
	// Please use following format to provide non-scalar default value:
	//	'[' + entry1 + ', ' + entry2 ... ']'
	//
	// NOTE: For non-scalar values, when default value is being assigned
	// by Cmd.Exec, it checks prefix '[' and suffix ']', and splits
	// elements by cutting around ', '.
	DefaultValue string

	// State is the current state of the flag.
	State FlagState
}

FlagInfo is a pack of the flag name, shorthand, default value and current state.

type FlagIter ¶

type FlagIter interface {
	// NthFlag returns the i-th flag's info this iterator can find.
	//
	// The bool return value indicates whether there is i-th flag, on
	// returning false, call with any value greater than i should return
	// false as well.
	NthFlag(i int) (FlagInfo, bool)
}

FlagIter

type FlagLevel ¶

type FlagLevel interface {
	// TrimAllLevelPrefixes tirms all prefixes belonging to each level.
	TrimAllLevelPrefixes(name string) string

	// GetFullFlagName adds all prefixes to name.
	GetFullFlagName(name string) string
}

FlagLevel

type FlagReflect ¶

type FlagReflect struct {
	VP           VP[*reflect.Value]
	Value        reflect.Value
	BriefUsage   string
	DefaultValue string
	Comp         []string
	State_       FlagState
}

FlagReflect

It is used internally by the ReflectIndexer.

func (f *FlagReflect) Decode(opts *ParseOptions, name, arg string, set bool) error

func (f *FlagReflect) Default() string

func (f *FlagReflect) Extra() any

func (f *FlagReflect) HasValue() bool

func (f *FlagReflect) ImplyValue() (string, bool)

func (f *FlagReflect) PrintValue(out io.Writer) (int, error)

func (f *FlagReflect) State() FlagState

func (f *FlagReflect) Suggest(tsk *CompTask) (added int, _ CompState)

func (f *FlagReflect) Type() (string, bool)

func (f *FlagReflect) Usage() string

type FlagState ¶

type FlagState uint32

FlagState contains bits representing a Flag's state.

const (
	// FlagStateValueChanged marks the value of the flag is changed.
	//
	// It SHOULD only be set inside method Flag.Decode when set is true.
	FlagStateValueChanged FlagState = 1 << iota

	// FlagStateHidden marks the flag hidden.
	FlagStateHidden

	// FlagStateSetAtMostOnce marks the flag should only enjoy successful
	// decoding with set=true at most once.
	FlagStateSetAtMostOnce
)

func (m FlagState) Hidden() bool

func (m FlagState) SetAtMostOnce() bool

func (m FlagState) ValueChanged() bool

type FlagViolation ¶

type FlagViolation Violation

A FlagViolation represents a rule violation caused by flag.

func (err *FlagViolation) Error() string

type Float32 ¶

type Float32 = FlagBase[float32, VPFloat[float32]]

predefined flag types for scalar values from command line.

type Float32Slice ¶

type Float32Slice = FlagBase[[]float32, VPSlice[float32, VPFloat[float32]]]

predefined flag types for slice values from command line.

type Float32SliceV ¶

type Float32SliceV = FlagBaseV[[]float32, VPSlice[float32, VPFloat[float32]]]

predefined flag types for slice values from command line.

type Float32Sum ¶

type Float32Sum = FlagBase[float32, VPSum[float32, VPFloat[float32]]]

predefined flag types for sumed scalar values from command line.

type Float32SumV ¶

type Float32SumV = FlagBaseV[float32, VPSum[float32, VPFloat[float32]]]

predefined flag types for sumed scalar values from command line.

type Float32V ¶

type Float32V = FlagBaseV[float32, VPFloat[float32]]

predefined flag types for scalar values from command line.

type Float64 ¶

type Float64 = FlagBase[float64, VPFloat[float64]]

predefined flag types for scalar values from command line.

type Float64Slice ¶

type Float64Slice = FlagBase[[]float64, VPSlice[float64, VPFloat[float64]]]

predefined flag types for slice values from command line.

type Float64SliceV ¶

type Float64SliceV = FlagBaseV[[]float64, VPSlice[float64, VPFloat[float64]]]

predefined flag types for slice values from command line.

type Float64Sum ¶

type Float64Sum = FlagBase[float64, VPSum[float64, VPFloat[float64]]]

predefined flag types for sumed scalar values from command line.

type Float64SumV ¶

type Float64SumV = FlagBaseV[float64, VPSum[float64, VPFloat[float64]]]

predefined flag types for sumed scalar values from command line.

type Float64V ¶

type Float64V = FlagBaseV[float64, VPFloat[float64]]

predefined flag types for scalar values from command line.

type FuncIndexer ¶

type FuncIndexer func(flag string, index int) (f Flag, info FlagInfo, ok bool)

FuncIndexer wraps a function as FlagIndexer.

when index < 0, act as FlagFinder, otherwise act as FlagIter.

func (fn FuncIndexer) FindFlag(name string) (Flag, bool)

func (fn FuncIndexer) NthFlag(i int) (info FlagInfo, ok bool)

type HelpHandleFunc ¶

type HelpHandleFunc = func(
	opts *CmdOptions, route Route, args []string, helpArgAt int,
) error

HelpHandleFunc for handling help requests.

when helpArgAt < 0, this function was called as the fallback of ArgErrorHandleFunc, and the argErr is discarded.

when helpArgAt >= 0, args[helpArgAt] is the arg initiated the help request, in this case return nil error will be replaced with ErrHelpRequestHandled{}.

type HelperTerminal ¶

type HelperTerminal interface {
	// HelplnCmdTerminal writes help messages for the target command
	// with a newline in the end.
	HelplnCmdTerminal(out io.Writer, route Route, linePrefix string) (int, error)

	// HelplnFlagTerminal writes help meesages for the flag with a newline
	// in the end.
	HelplnFlagTerminal(
		out io.Writer, route Route, linePrefix string,
		indent int, flag FlagInfo, groupHasShorthand bool,
	) (int, error)
}

HelperTerminal writes help messages for a terminal user.

type Inspector ¶

type Inspector interface {
	// CheckFlagValueChanged returns ture if the flag's value has been changed.
	CheckFlagValueChanged(key string) bool
}

An Inspector is an external verifier used to check rule enforcement.

type Int ¶

type Int = FlagBase[int, VPInt[int]]

predefined flag types for scalar values from command line.

type Int16 ¶

type Int16 = FlagBase[int16, VPInt[int16]]

predefined flag types for scalar values from command line.

type Int16Slice ¶

type Int16Slice = FlagBase[[]int16, VPSlice[int16, VPInt[int16]]]

predefined flag types for slice values from command line.

type Int16SliceV ¶

type Int16SliceV = FlagBaseV[[]int16, VPSlice[int16, VPInt[int16]]]

predefined flag types for slice values from command line.

type Int16Sum ¶

type Int16Sum = FlagBase[int16, VPSum[int16, VPInt[int16]]]

predefined flag types for sumed scalar values from command line.

type Int16SumV ¶

type Int16SumV = FlagBaseV[int16, VPSum[int16, VPInt[int16]]]

predefined flag types for sumed scalar values from command line.

type Int16V ¶

type Int16V = FlagBaseV[int16, VPInt[int16]]

predefined flag types for scalar values from command line.

type Int32 ¶

type Int32 = FlagBase[int32, VPInt[int32]]

predefined flag types for scalar values from command line.

type Int32Slice ¶

type Int32Slice = FlagBase[[]int32, VPSlice[int32, VPInt[int32]]]

predefined flag types for slice values from command line.

type Int32SliceV ¶

type Int32SliceV = FlagBaseV[[]int32, VPSlice[int32, VPInt[int32]]]

predefined flag types for slice values from command line.

type Int32Sum ¶

type Int32Sum = FlagBase[int32, VPSum[int32, VPInt[int32]]]

predefined flag types for sumed scalar values from command line.

type Int32SumV ¶

type Int32SumV = FlagBaseV[int32, VPSum[int32, VPInt[int32]]]

predefined flag types for sumed scalar values from command line.

type Int32V ¶

type Int32V = FlagBaseV[int32, VPInt[int32]]

predefined flag types for scalar values from command line.

type Int64 ¶

type Int64 = FlagBase[int64, VPInt[int64]]

predefined flag types for scalar values from command line.

type Int64Slice ¶

type Int64Slice = FlagBase[[]int64, VPSlice[int64, VPInt[int64]]]

predefined flag types for slice values from command line.

type Int64SliceV ¶

type Int64SliceV = FlagBaseV[[]int64, VPSlice[int64, VPInt[int64]]]

predefined flag types for slice values from command line.

type Int64Sum ¶

type Int64Sum = FlagBase[int64, VPSum[int64, VPInt[int64]]]

predefined flag types for sumed scalar values from command line.

type Int64SumV ¶

type Int64SumV = FlagBaseV[int64, VPSum[int64, VPInt[int64]]]

predefined flag types for sumed scalar values from command line.

type Int64V ¶

type Int64V = FlagBaseV[int64, VPInt[int64]]

predefined flag types for scalar values from command line.

type Int8 ¶

type Int8 = FlagBase[int8, VPInt[int8]]

predefined flag types for scalar values from command line.

type Int8Slice ¶

type Int8Slice = FlagBase[[]int8, VPSlice[int8, VPInt[int8]]]

predefined flag types for slice values from command line.

type Int8SliceV ¶

type Int8SliceV = FlagBaseV[[]int8, VPSlice[int8, VPInt[int8]]]

predefined flag types for slice values from command line.

type Int8Sum ¶

type Int8Sum = FlagBase[int8, VPSum[int8, VPInt[int8]]]

predefined flag types for sumed scalar values from command line.

type Int8SumV ¶

type Int8SumV = FlagBaseV[int8, VPSum[int8, VPInt[int8]]]

predefined flag types for sumed scalar values from command line.

type Int8V ¶

type Int8V = FlagBaseV[int8, VPInt[int8]]

predefined flag types for scalar values from command line.

type IntSlice ¶

type IntSlice = FlagBase[[]int, VPSlice[int, VPInt[int]]]

predefined flag types for slice values from command line.

type IntSliceV ¶

type IntSliceV = FlagBaseV[[]int, VPSlice[int, VPInt[int]]]

predefined flag types for slice values from command line.

type IntSum ¶

type IntSum = FlagBase[int, VPSum[int, VPInt[int]]]

predefined flag types for sumed scalar values from command line.

type IntSumV ¶

type IntSumV = FlagBaseV[int, VPSum[int, VPInt[int]]]

predefined flag types for sumed scalar values from command line.

type IntV ¶

type IntV = FlagBaseV[int, VPInt[int]]

predefined flag types for scalar values from command line.

type LevelIndexer ¶

type LevelIndexer struct {
	// Up points to the up level, if any.
	Up FlagLevel

	// Prefix is the prefix to identify this level.
	//
	// Should not be empty for non-root level.
	Prefix string

	// Flags
	Flags FlagFinderMaybeIter
	// contains filtered or unexported fields
}

LevelIndexer is a FlagFinder wrapper to build multi-level flag hierarchy.

func (l *LevelIndexer) FindFlag(name string) (Flag, bool)

func (l *LevelIndexer) GetFullFlagName(name string) string

func (l *LevelIndexer) NthFlag(i int) (info FlagInfo, ok bool)

func (l *LevelIndexer) TrimAllLevelPrefixes(name string) string

type MapIndexer ¶

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

MapIndexer implements FlagIndexer using built-in maps.

func NewMapIndexer() *MapIndexer

func (m *MapIndexer) Add(flag Flag, names ...string) *MapIndexer

func (m *MapIndexer) AddWithDefaultValue(defaultValue string, flag Flag, names ...string) *MapIndexer

func (m *MapIndexer) FindFlag(name string) (Flag, bool)

func (m *MapIndexer) NthFlag(i int) (info FlagInfo, ok bool)

type MapIntBool ¶

type MapIntBool = FlagBase[map[int]bool, VPMap[int, bool, VPInt[int], VPBool[bool]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntBoolSlice ¶

type MapIntBoolSlice = FlagBase[map[int][]bool, VPMap[int, []bool, VPInt[int], VPSlice[bool, VPBool[bool]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntBoolSliceV ¶

type MapIntBoolSliceV = FlagBase[map[int][]bool, VPMap[int, []bool, VPInt[int], VPSlice[bool, VPBool[bool]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntBoolV ¶

type MapIntBoolV = FlagBase[map[int]bool, VPMap[int, bool, VPInt[int], VPBool[bool]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntDuration ¶

type MapIntDuration = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPDuration[time.Duration]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntDurationSlice ¶

type MapIntDurationSlice = FlagBase[map[int][]time.Duration, VPMap[int, []time.Duration, VPInt[int], VPSlice[time.Duration, VPDuration[time.Duration]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntDurationSliceV ¶

type MapIntDurationSliceV = FlagBase[map[int][]time.Duration, VPMap[int, []time.Duration, VPInt[int], VPSlice[time.Duration, VPDuration[time.Duration]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntDurationSum ¶

type MapIntDurationSum = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPSum[time.Duration, VPDuration[time.Duration]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntDurationSumV ¶

type MapIntDurationSumV = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPSum[time.Duration, VPDuration[time.Duration]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntDurationV ¶

type MapIntDurationV = FlagBase[map[int]time.Duration, VPMap[int, time.Duration, VPInt[int], VPDuration[time.Duration]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat32 ¶

type MapIntFloat32 = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPFloat[float32]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat32Slice ¶

type MapIntFloat32Slice = FlagBase[map[int][]float32, VPMap[int, []float32, VPInt[int], VPSlice[float32, VPFloat[float32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat32SliceV ¶

type MapIntFloat32SliceV = FlagBase[map[int][]float32, VPMap[int, []float32, VPInt[int], VPSlice[float32, VPFloat[float32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat32Sum ¶

type MapIntFloat32Sum = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPSum[float32, VPFloat[float32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat32SumV ¶

type MapIntFloat32SumV = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPSum[float32, VPFloat[float32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat32V ¶

type MapIntFloat32V = FlagBase[map[int]float32, VPMap[int, float32, VPInt[int], VPFloat[float32]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat64 ¶

type MapIntFloat64 = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPFloat[float64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat64Slice ¶

type MapIntFloat64Slice = FlagBase[map[int][]float64, VPMap[int, []float64, VPInt[int], VPSlice[float64, VPFloat[float64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat64SliceV ¶

type MapIntFloat64SliceV = FlagBase[map[int][]float64, VPMap[int, []float64, VPInt[int], VPSlice[float64, VPFloat[float64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat64Sum ¶

type MapIntFloat64Sum = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPSum[float64, VPFloat[float64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat64SumV ¶

type MapIntFloat64SumV = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPSum[float64, VPFloat[float64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntFloat64V ¶

type MapIntFloat64V = FlagBase[map[int]float64, VPMap[int, float64, VPInt[int], VPFloat[float64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt ¶

type MapIntInt = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPInt[int]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt16 ¶

type MapIntInt16 = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPInt[int16]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt16Slice ¶

type MapIntInt16Slice = FlagBase[map[int][]int16, VPMap[int, []int16, VPInt[int], VPSlice[int16, VPInt[int16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt16SliceV ¶

type MapIntInt16SliceV = FlagBase[map[int][]int16, VPMap[int, []int16, VPInt[int], VPSlice[int16, VPInt[int16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt16Sum ¶

type MapIntInt16Sum = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPSum[int16, VPInt[int16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt16SumV ¶

type MapIntInt16SumV = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPSum[int16, VPInt[int16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt16V ¶

type MapIntInt16V = FlagBase[map[int]int16, VPMap[int, int16, VPInt[int], VPInt[int16]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt32 ¶

type MapIntInt32 = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPInt[int32]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt32Slice ¶

type MapIntInt32Slice = FlagBase[map[int][]int32, VPMap[int, []int32, VPInt[int], VPSlice[int32, VPInt[int32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt32SliceV ¶

type MapIntInt32SliceV = FlagBase[map[int][]int32, VPMap[int, []int32, VPInt[int], VPSlice[int32, VPInt[int32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt32Sum ¶

type MapIntInt32Sum = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPSum[int32, VPInt[int32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt32SumV ¶

type MapIntInt32SumV = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPSum[int32, VPInt[int32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt32V ¶

type MapIntInt32V = FlagBase[map[int]int32, VPMap[int, int32, VPInt[int], VPInt[int32]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt64 ¶

type MapIntInt64 = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPInt[int64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt64Slice ¶

type MapIntInt64Slice = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPInt[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt64SliceV ¶

type MapIntInt64SliceV = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPInt[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt64Sum ¶

type MapIntInt64Sum = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPInt[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt64SumV ¶

type MapIntInt64SumV = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPInt[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt64V ¶

type MapIntInt64V = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPInt[int64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt8 ¶

type MapIntInt8 = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPInt[int8]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt8Slice ¶

type MapIntInt8Slice = FlagBase[map[int][]int8, VPMap[int, []int8, VPInt[int], VPSlice[int8, VPInt[int8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt8SliceV ¶

type MapIntInt8SliceV = FlagBase[map[int][]int8, VPMap[int, []int8, VPInt[int], VPSlice[int8, VPInt[int8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt8Sum ¶

type MapIntInt8Sum = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPSum[int8, VPInt[int8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt8SumV ¶

type MapIntInt8SumV = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPSum[int8, VPInt[int8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntInt8V ¶

type MapIntInt8V = FlagBase[map[int]int8, VPMap[int, int8, VPInt[int], VPInt[int8]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntIntSlice ¶

type MapIntIntSlice = FlagBase[map[int][]int, VPMap[int, []int, VPInt[int], VPSlice[int, VPInt[int]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntIntSliceV ¶

type MapIntIntSliceV = FlagBase[map[int][]int, VPMap[int, []int, VPInt[int], VPSlice[int, VPInt[int]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntIntSum ¶

type MapIntIntSum = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPSum[int, VPInt[int]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntIntSumV ¶

type MapIntIntSumV = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPSum[int, VPInt[int]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntIntV ¶

type MapIntIntV = FlagBase[map[int]int, VPMap[int, int, VPInt[int], VPInt[int]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexp ¶

type MapIntRegexp = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexpNocase ¶

type MapIntRegexpNocase = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexpNocaseSlice ¶

type MapIntRegexpNocaseSlice = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexpNocaseSliceV ¶

type MapIntRegexpNocaseSliceV = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexpNocaseV ¶

type MapIntRegexpNocaseV = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexpNocase[regexp.Regexp]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexpSlice ¶

type MapIntRegexpSlice = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexpSliceV ¶

type MapIntRegexpSliceV = FlagBase[map[int][]*regexp.Regexp, VPMap[int, []*regexp.Regexp, VPInt[int], VPSlice[*regexp.Regexp, VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntRegexpV ¶

type MapIntRegexpV = FlagBase[map[int]*regexp.Regexp, VPMap[int, *regexp.Regexp, VPInt[int], VPPointer[regexp.Regexp, VPRegexp[regexp.Regexp]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntSize ¶

type MapIntSize = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSize[int64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntSizeSlice ¶

type MapIntSizeSlice = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPSize[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntSizeSliceV ¶

type MapIntSizeSliceV = FlagBase[map[int][]int64, VPMap[int, []int64, VPInt[int], VPSlice[int64, VPSize[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntSizeSum ¶

type MapIntSizeSum = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPSize[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntSizeSumV ¶

type MapIntSizeSumV = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSum[int64, VPSize[int64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntSizeV ¶

type MapIntSizeV = FlagBase[map[int]int64, VPMap[int, int64, VPInt[int], VPSize[int64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntString ¶

type MapIntString = FlagBase[map[int]string, VPMap[int, string, VPInt[int], VPString[string]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntStringSlice ¶

type MapIntStringSlice = FlagBase[map[int][]string, VPMap[int, []string, VPInt[int], VPSlice[string, VPString[string]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntStringSliceV ¶

type MapIntStringSliceV = FlagBase[map[int][]string, VPMap[int, []string, VPInt[int], VPSlice[string, VPString[string]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntStringV ¶

type MapIntStringV = FlagBase[map[int]string, VPMap[int, string, VPInt[int], VPString[string]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntTime ¶

type MapIntTime = FlagBase[map[int]time.Time, VPMap[int, time.Time, VPInt[int], VPTime[time.Time]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntTimeSlice ¶

type MapIntTimeSlice = FlagBase[map[int][]time.Time, VPMap[int, []time.Time, VPInt[int], VPSlice[time.Time, VPTime[time.Time]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntTimeSliceV ¶

type MapIntTimeSliceV = FlagBase[map[int][]time.Time, VPMap[int, []time.Time, VPInt[int], VPSlice[time.Time, VPTime[time.Time]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntTimeV ¶

type MapIntTimeV = FlagBase[map[int]time.Time, VPMap[int, time.Time, VPInt[int], VPTime[time.Time]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint ¶

type MapIntUint = FlagBase[map[int]uint, VPMap[int, uint, VPInt[int], VPUint[uint]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint16 ¶

type MapIntUint16 = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPUint[uint16]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint16Slice ¶

type MapIntUint16Slice = FlagBase[map[int][]uint16, VPMap[int, []uint16, VPInt[int], VPSlice[uint16, VPUint[uint16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint16SliceV ¶

type MapIntUint16SliceV = FlagBase[map[int][]uint16, VPMap[int, []uint16, VPInt[int], VPSlice[uint16, VPUint[uint16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint16Sum ¶

type MapIntUint16Sum = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPSum[uint16, VPUint[uint16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint16SumV ¶

type MapIntUint16SumV = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPSum[uint16, VPUint[uint16]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint16V ¶

type MapIntUint16V = FlagBase[map[int]uint16, VPMap[int, uint16, VPInt[int], VPUint[uint16]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint32 ¶

type MapIntUint32 = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPUint[uint32]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint32Slice ¶

type MapIntUint32Slice = FlagBase[map[int][]uint32, VPMap[int, []uint32, VPInt[int], VPSlice[uint32, VPUint[uint32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint32SliceV ¶

type MapIntUint32SliceV = FlagBase[map[int][]uint32, VPMap[int, []uint32, VPInt[int], VPSlice[uint32, VPUint[uint32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint32Sum ¶

type MapIntUint32Sum = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPSum[uint32, VPUint[uint32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint32SumV ¶

type MapIntUint32SumV = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPSum[uint32, VPUint[uint32]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint32V ¶

type MapIntUint32V = FlagBase[map[int]uint32, VPMap[int, uint32, VPInt[int], VPUint[uint32]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint64 ¶

type MapIntUint64 = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPUint[uint64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint64Slice ¶

type MapIntUint64Slice = FlagBase[map[int][]uint64, VPMap[int, []uint64, VPInt[int], VPSlice[uint64, VPUint[uint64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint64SliceV ¶

type MapIntUint64SliceV = FlagBase[map[int][]uint64, VPMap[int, []uint64, VPInt[int], VPSlice[uint64, VPUint[uint64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint64Sum ¶

type MapIntUint64Sum = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPSum[uint64, VPUint[uint64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint64SumV ¶

type MapIntUint64SumV = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPSum[uint64, VPUint[uint64]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint64V ¶

type MapIntUint64V = FlagBase[map[int]uint64, VPMap[int, uint64, VPInt[int], VPUint[uint64]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint8 ¶

type MapIntUint8 = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPUint[uint8]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint8Slice ¶

type MapIntUint8Slice = FlagBase[map[int][]uint8, VPMap[int, []uint8, VPInt[int], VPSlice[uint8, VPUint[uint8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint8SliceV ¶

type MapIntUint8SliceV = FlagBase[map[int][]uint8, VPMap[int, []uint8, VPInt[int], VPSlice[uint8, VPUint[uint8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint8Sum ¶

type MapIntUint8Sum = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPSum[uint8, VPUint[uint8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint8SumV ¶

type MapIntUint8SumV = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPSum[uint8, VPUint[uint8]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUint8V ¶

type MapIntUint8V = FlagBase[map[int]uint8, VPMap[int, uint8, VPInt[int], VPUint[uint8]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUintSlice ¶

type MapIntUintSlice = FlagBase[map[int][]uint, VPMap[int, []uint, VPInt[int], VPSlice[uint, VPUint[uint]]]]

predefined flag types for "<int>=<scalar>" from command line.

type MapIntUintSliceV ¶