cmds

type Argument struct {
	Name          string
	Type          ArgumentType
	Required      bool // error if no value is specified
	Variadic      bool // unlimited values can be specfied
	SupportsStdin bool // can accept stdin as a value
	Recursive     bool // supports recursive file adding (with '-r' flag)
	Description   string
}

type ArgumentType int

type Command struct {
	// Options defines the flags accepted by the command. Flags on specified
	// on parent commands are inherited by sub commands.
	Options []Option

	// Arguments defines the positional arguments for the command. These
	// arguments can be strings and/or files.
	//
	// The rules for valid arguments are as follows:
	//
	// 1. No required arguments may follow optional arguments.
	// 2. There can be at most one STDIN argument.
	// 3. There can be at most one variadic argument, and it must be last.
	Arguments []Argument

	// PreRun is run before Run. When executing a command on a remote
	// daemon, PreRun is always run in the local process.
	PreRun func(req *Request, env Environment) error

	// Run is the function that processes the request to generate a response.
	// Note that when executing the command over the HTTP API you can only read
	// after writing when using multipart requests. The request body will not be
	// available for reading after the HTTP connection has been written to.
	Run Function

	// PostRun is run after Run, and can transform results returned by run.
	// When executing a command on a remote daemon, PostRun is always run in
	// the local process.
	PostRun PostRunMap

	// Encoders encode results from Run (and/or PostRun) in the desired
	// encoding.
	Encoders EncoderMap

	// Helptext is the command's help text.
	Helptext HelpText

	// RunTimeout is the default timeout for this particular command.
	// The timeout limits the start of the Run function to the end of the
	// response emittance.
	// If unset (Duration = 0), there is no timeout.
	// If the global CLI --timeout is set, this timeout is overridden by
	// the --timeout value.
	RunTimeout time.Duration

	// External denotes that a command is actually an external binary.
	// fewer checks and validations will be performed on such commands.
	External bool

	// Type describes the type of the output of the Command's Run Function.
	// In precise terms, the value of Type is an instance of the return type of
	// the Run Function.
	//
	// ie. If command Run returns &Block{}, then Command.Type == &Block{}
	Type interface{}

	// Subcommands allow attaching sub commands to a command.
	//
	// Note: A command can specify both a Run function and Subcommands. If
	// invoked with no arguments, or an argument that matches no
	// sub commands, the Run function of the current command will be invoked.
	//
	// Take care when specifying both a Run function and Subcommands. A
	// simple typo in a sub command will invoke the parent command and may
	// end up returning a cryptic error to the user.
	Subcommands map[string]*Command

	// NoRemote denotes that a command cannot be executed in a remote environment
	NoRemote bool

	// NoLocal denotes that a command cannot be executed in a local environment
	NoLocal bool

	// Extra contains a set of other command-specific parameters
	Extra *Extra
}

type CommandVisitor func(*Command)

type Decoder interface {
	Decode(value interface{}) error
}

type Encoder interface {
	Encode(value interface{}) error
}

type EncoderFunc func(req *Request) func(w io.Writer) Encoder

type EncoderMap map[EncodingType]EncoderFunc

type EncodingType string

type Environment interface{}

type Error struct {
	Message string
	Code    ErrorType
}

type ErrorType uint

type Executor interface {
	Execute(req *Request, re ResponseEmitter, env Environment) error
}

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

type Flusher interface {
	Flush() error
}

type Function func(*Request, ResponseEmitter, Environment) error

type HelpText struct {
	// required
	Tagline               string            // used in <cmd usage>
	ShortDescription      string            // used in DESCRIPTION
	SynopsisOptionsValues map[string]string // mappings for synopsis generator

	// optional - whole section overrides
	Usage           string // overrides USAGE section
	LongDescription string // overrides DESCRIPTION section
	Options         string // overrides OPTIONS section
	Arguments       string // overrides ARGUMENTS section
	Subcommands     string // overrides SUBCOMMANDS section
	Synopsis        string // overrides SYNOPSIS field
}

type MakeEnvironment func(context.Context, *Request) (Environment, error)

type MakeExecutor func(*Request, interface{}) (Executor, error)

type MaybeError struct {
	Value interface{} // needs to be a pointer
	Error *Error
	// contains filtered or unexported fields
}

type OptMap map[string]interface{}

type Option interface {
	Name() string    // the main name of the option
	Names() []string // a list of unique names matched with user-provided flags

	Type() reflect.Kind  // value must be this type
	Description() string // a short string that describes this option

	WithDefault(interface{}) Option // sets the default value of the option
	Default() interface{}

	Parse(str string) (interface{}, error)
}

type PostRunMap map[PostRunType]func(Response, ResponseEmitter) error

type PostRunType string

type ReqLog struct {
	Requests []*ReqLogEntry
	// contains filtered or unexported fields
}

type ReqLogEntry struct {
	StartTime time.Time
	EndTime   time.Time
	Active    bool
	Command   string
	Options   map[string]interface{}
	Args      []string
	ID        int
}

type Request struct {
	Context       context.Context
	Root, Command *Command

	Path      []string
	Arguments []string
	Options   OptMap

	Files files.Directory
	// contains filtered or unexported fields
}

type Response interface {
	Request() *Request

	Error() *Error
	Length() uint64

	// Next returns the next emitted value.
	// The returned error can be a network or decoding error.
	Next() (interface{}, error)
}

type ResponseEmitter interface {
	// Close closes the underlying transport.
	Close() error

	// CloseWithError closes the underlying transport and makes subsequent read
	// calls return the passed error.
	CloseWithError(error) error

	// SetLength sets the length of the output
	// err is an interface{} so we don't have to manually convert to error.
	SetLength(length uint64)

	// Emit sends a value.
	// If value is io.Reader we just copy that to the connection
	// other values are marshalled.
	Emit(value interface{}) error

	// Record the key event in the emit, used for profile the program
	RecordEvent(str string)

	//Show the event report for time used while execute the command
	ShowEventReport() string
}

type Single struct {
	Value interface{}
}

type StdinArguments interface {
	io.ReadCloser

	// Scan reads in the next argument and returns true if there is an
	// argument to read.
	Scan() bool

	// Argument returns the next argument.
	Argument() string

	// Err returns any errors encountered when reading in arguments.
	Err() error
}

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

type TimeEvaluate struct {
	TmVal   []time.Time
	TmIndex int
	Event   []string
}