fsm

type Distributable interface {
	GetDistributableItems() interface{}
}

type DistributableItem interface {
	GetItemID() string
	SetNodeID(string)
}

type DistributeRequest struct {
	Data interface{}
}

type DistributeService struct {
	Picker
}

type Distributor struct {
	// StickyMap sticky item to the nodeID.
	StickyMap map[string]string
}

type FSM struct {
	RaftLogSum uint64
	// contains filtered or unexported fields
}

type KvExectable interface {
	Exec(req KvRequest) interface{}
}

type KvOperate string

type KvRequest struct {
	Value     interface{}
	KvOperate KvOperate
	MapName   string
	Key       string
}

type Map struct {
	Data map[string]interface{}
	// contains filtered or unexported fields
}

type MarshalTypesRegister interface {
	// RegisterMarshalTypes registers the types for marshaling and unmarshaling.
	RegisterMarshalTypes(reg *marshal.TypeRegister)
}

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

type Picker interface {
	PickForNode(node string, request interface{})
	MarshalTypesRegister
}

type PickerFn func(node string, request interface{})

type ReqTypeInfo struct {
	Service Service
	ReqType reflect.Type
}

type Service interface {
	// NewLog is called when a new raft log message is committed in the cluster and matched with any of the GetReqDataTypes returned types
	// in this method we can handle what should happen when we got a new raft log regarding our FSM service
	NewLog(shortNodeID string, request interface{}) interface{}

	// GetReqDataType returns all the request structs which are used by this FSMService
	GetReqDataType() interface{}

	// ApplySnapshot is used to decode and apply a snapshot to the FSMService
	ApplySnapshot(shortNodeID string, input interface{}) error

	MarshalTypesRegister
}

type Snapshot struct {
	sync.Mutex
	// contains filtered or unexported fields
}

type SubDataAware interface {
	GetSubData() interface{}
}

type SubDataTypeAware interface {
	GetSubDataType() reflect.Type
}