Documentation
¶
Overview ¶
Package transform provides transforms on commands.
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type DCE ¶ added in v0.6.0
type DCE struct {
// contains filtered or unexported fields
}
DCE contains an execution footprint built from a list of commands, and a list of requested command indices. It drives the back-propagation to drop commands which are not contributing to the final state at the requested commands.
func NewDCE ¶ added in v0.6.0
func NewDCE(ctx context.Context, footprint *dependencygraph.Footprint) *DCE
NewDCE constructs a new DCE instance and returns a pointer to the created DCE instance.
func (*DCE) Flush ¶ added in v0.6.0
Flush is to comform the interface of Transformer. Flush starts the back propagation of the behaviors recorded in the footprint from the last requested command (the one with largest SubCmdIdx, not the one added the last in the order of time) to get a list of alive commands. Then it sends the alive commands to the following transforms to mutate them and write them to build instructions for replay.
type DeadCodeElimination ¶
type DeadCodeElimination struct {
// contains filtered or unexported fields
}
DeadCodeElimination is an implementation of Transformer that outputs live commands. That is, all commands which do not affect the requested output are omitted. It is named after the standard compiler optimization. (state is like memory and commands are instructions which read/write it). Construct with NewDeadCodeElimination, do not build directly.
func NewDeadCodeElimination ¶
func NewDeadCodeElimination(ctx context.Context, depGraph *dependencygraph.DependencyGraph) *DeadCodeElimination
NewDeadCodeElimination constructs and returns a new DeadCodeElimination transform.
The transform generates commands from the given depGraph, it does not take inputs.
func (*DeadCodeElimination) Flush ¶
func (t *DeadCodeElimination) Flush(ctx context.Context, out Writer)
func (*DeadCodeElimination) Request ¶
func (t *DeadCodeElimination) Request(id api.CmdID)
Request ensures that we keep alive all commands needed to render framebuffer at the given point.
type Injector ¶
type Injector struct {
// contains filtered or unexported fields
}
Injector is an implementation of Transformer that can inject commands into the stream.
type Tasks ¶ added in v0.6.1
type Tasks struct {
// contains filtered or unexported fields
}
Tasks is a Transformer that calls functions when the specified command is reached or passed.
type Terminator ¶
type Terminator interface {
Transformer
// Add relaxes the termination limit to pass-through all commands before and
// including the command or subcommand.
Add(context.Context, api.CmdID, []uint64) error
}
Terminator is an Transformer that prevents commands passing-through it after a certain point in the stream.
func NewEarlyTerminator ¶
func NewEarlyTerminator(api api.ID) Terminator
NewEarlyTerminator returns a Terminator that will consume all commands of the given API type that come after the last command passed to Add.
type TransformWriter ¶
type TransformWriter struct {
S *api.GlobalState
T Transformer
O Writer
}
TransformWriter implements the Writer interface, transforming each command that is written with T, before writing the result to O.
func (TransformWriter) MutateAndWrite ¶
func (TransformWriter) State ¶
func (p TransformWriter) State() *api.GlobalState
type Transformer ¶
type Transformer interface {
// Transform takes a given command and identifier and Writes out a possibly
// transformed set of commands to the output.
// Transform must not modify cmd in any way.
Transform(ctx context.Context, id api.CmdID, cmd api.Cmd, output Writer)
// Flush is called at the end of a command stream to cause Transformers
// that cache commands to send any they have stored into the output.
Flush(ctx context.Context, output Writer)
}
Transformer is the interface that wraps the basic Transform method.
func NewFileLog ¶
func NewFileLog(ctx context.Context, path string) Transformer
NewFileLog returns a Transformer that will log all commands passed through it to the text file at path.
type Transforms ¶
type Transforms []Transformer
Transforms is a list of Transformer objects.
func (*Transforms) Add ¶
func (l *Transforms) Add(t ...Transformer)
Add is a convenience function for appending the list of Transformers t to the end of the Transforms list, after filtering out nil Transformers.
func (*Transforms) Prepend ¶
func (l *Transforms) Prepend(t Transformer)
Prepend adds the given transformer to the beginning of the transform chain.
type Writer ¶
type Writer interface {
// State returns the state object associated with this writer.
State() *api.GlobalState
// MutateAndWrite mutates the state object associated with this writer,
// and it passes the command to further consumers.
MutateAndWrite(ctx context.Context, id api.CmdID, cmd api.Cmd)
}
Writer is the interface which consumes the output of an Transformer. It also keeps track of state changes caused by all commands written to it. Conceptually, each Writer object contains its own separate State object, which is modified when MutateAndWrite is called. This allows the transform to access the state both before and after the mutation of state happens. It is also possible to omit/insert commands. In practice, single state object can be shared by all transforms for performance (i.e. the mutation is done only once at the very end). This potentially allows state changes to leak upstream so care is needed. There is a configuration flag to switch between the shared/separate modes.
Source Files