sio

type Changed struct {
	State   *core.State      `json:",omitempty"`
	SpecSrc *crew.SpecSource `json:",omitempty"`
	Deleted bool             `json:",omitempty"`

	// PreviousState is optional data that can be used to decide
	// if the new state is really different from the old state.
	//
	// In this implementation, PreviousState is a JSON
	// representation of this struct.
	PreviousState []byte `json:"-"`
}

type Couplings interface {
	// Start initializes the Couplings.
	Start(context.Context) error

	// IO returns the input and result channels.
	//
	// Consumer can see all emitted messages and state updates via
	// the Result(s).
	IO(context.Context) (chan interface{}, chan *Result, chan bool, error)

	// Read (optionally) returns an initial set of machines.
	//
	// An implementation that supports persistence would read
	// machine state and pass it to this method.
	Read(context.Context) (map[string]*crew.Machine, error)

	// Stop shuts down the Couplings.
	Stop(context.Context) error
}

type Crew struct {
	// Machines represents this's Crews current machines.
	Machines map[string]*crew.Machine

	// Conf provides some basic Crew parameters.
	Conf *CrewConf `json:"conf"`

	// Verbose turns on logging.
	Verbose bool

	// Mutex can probably be removed once code is cleaned up to
	// perform all state changes, including timers state changes,
	// the Crew loop.  ToDo.
	sync.Mutex
	// contains filtered or unexported fields
}

type CrewConf struct {
	Id  string        `json:"id,omitempty"`
	Ctl *core.Control `json:"ctl"`
}

type CrewOp struct {
	Update map[string]*crew.Machine `json:"update,omitempty"`
	Delete []string                 `json:"delete,omitempty"`
}

type JSONStore struct {
	// StateOutputFilename, if not empty, will be the filename
	// writing state as JSON.
	StateOutputFilename string

	// StateInputFilename optionall gives a filename that contains
	// state to return when Read is called.
	StateInputFilename string

	WG sync.WaitGroup
	// contains filtered or unexported fields
}

type Limits struct {
	MaxSheens        int `json:"maxSheens"`
	MaxStatePerSheen int `json:"maxStatePerSheen"`
}

type Result struct {
	// Changed represents all machine changes.
	Changed map[string]*Changed

	// Emitted is list of message batches emitted by machines
	// during processing.
	//
	// A message batch is ordered: A machine (usually) emits
	// messages in a specified, deterministic order.
	//
	// The collection of batches is a partial order given by
	// recursive message processing calls.  When processing a
	// message results in emitted messages that are directed back
	// to the crew, the results of those recursive processings
	// give a determinstic order their emitted batches.  However,
	// with respect to a processig a single message, multiple
	// batches are NOT orders (because the order that machines are
	// presented with an in-bound message is not specified).
	Emitted [][]interface{}

	// Diag includes internal processing data.
	Diag []*Stroll
}

type Stdio struct {
	// In is coupled to crew input.
	In io.Reader

	// Out is coupled to crew output.
	Out io.Writer

	// ShellExpand enables input to include inline shell commands
	// delimited by '<<' and '>>'.  Use at your wown risk, of
	// course!
	ShellExpand bool

	// Timestamps prepends a timestamp to each output line.
	Timestamps bool

	// EchoInput writes input lines (prepended with "input") to
	// the output.
	EchoInput bool

	// Tags prefixes tags indicating type of output ("input",
	// "emit", "diag").
	Tags bool

	// PadTags adds some padding to tags ("input", "emit",
	// "update") used in output.
	PadTags bool

	// PrintUpdates will print update messages to stdout.
	PrintUpdates bool

	JSONStore

	// InputEOF will be closed on EOF from stdin.
	InputEOF chan bool

	// WriteStatePerMsg will write out ALL state after every input
	// message is processed.
	//
	// Inefficient!
	WriteStatePerMsg bool

	// PrintDiag turns on printing of diagnostic data.
	PrintDiag bool
}

type Stroll struct {
	Msg     interface{} `json:"msg"`
	Walkeds interface{} `json:"walks"`
	Err     string      `json:"err,omitempty"`
}

type TimerEntry struct {
	Id  string
	Msg interface{}
	At  time.Time
	Ctl chan bool `json:"-"`
	// contains filtered or unexported fields
}

type TimerMsg struct {

	// Add the given timer.
	Add struct {
		Id  string      `json:"id"`
		Msg interface{} `json:"msg"`
		In  string      `json:"in"`
		To  string      `json:"to"` // ToDo: Support array
	} `json:"makeTimer"`

	// Cancel the given timer.
	Cancel struct {
		Id string
	} `json:"cancelTimer"`
}

type Timers struct {
	Map     map[string]*TimerEntry
	Emitter func(context.Context, *TimerEntry) `json:"-"`

	sync.Mutex
	// contains filtered or unexported fields
}