counter

type CounterState struct {
	meta.ObjectMeta `protobuf:"bytes,1,opt,name=meta,proto3,embedded=meta" json:"meta"`
	Value           int64 `protobuf:"varint,2,opt,name=value,proto3" json:"value,omitempty"`
}

type DecrementProposal interface {
	Proposal
	Request() *counter.DecrementRequest
}

type DecrementProposals interface {
	Get(ProposalID) (DecrementProposal, bool)
	List() []DecrementProposal
}

type GetQuery interface {
	Query
	Request() *counter.GetRequest
}

type IncrementProposal interface {
	Proposal
	Request() *counter.IncrementRequest
}

type IncrementProposals interface {
	Get(ProposalID) (IncrementProposal, bool)
	List() []IncrementProposal
}

type NewServiceFunc func(ServiceContext) Service

type Proposal interface {
	fmt.Stringer
	ID() ProposalID
	Session() Session
	State() ProposalState
	Watch(func(ProposalState)) Watcher
}

type ProposalID uint64

type ProposalState int

type Proposals interface {
	Set() SetProposals
	Increment() IncrementProposals
	Decrement() DecrementProposals
}

type Query interface {
	fmt.Stringer
	Session() Session
}

type Service interface {
	ServiceContext
	Backup(SnapshotWriter) error
	Restore(SnapshotReader) error
	// Set sets the counter value
	Set(SetProposal) (*counter.SetResponse, error)
	// Get gets the current counter value
	Get(GetQuery) (*counter.GetResponse, error)
	// Increment increments the counter value
	Increment(IncrementProposal) (*counter.IncrementResponse, error)
	// Decrement decrements the counter value
	Decrement(DecrementProposal) (*counter.DecrementResponse, error)
}

type ServiceAdaptor struct {
	rsm.ServiceContext
	// contains filtered or unexported fields
}

type ServiceContext interface {
	Scheduler() rsm.Scheduler
	Sessions() Sessions
	Proposals() Proposals
}

type Session interface {
	ID() SessionID
	State() SessionState
	Watch(func(SessionState)) Watcher
	Proposals() Proposals
}

type SessionID uint64

type SessionState int

type Sessions interface {
	Get(SessionID) (Session, bool)
	List() []Session
}

type SetProposal interface {
	Proposal
	Request() *counter.SetRequest
}

type SetProposals interface {
	Get(ProposalID) (SetProposal, bool)
	List() []SetProposal
}

type SnapshotReader interface {
	ReadState() (*CounterState, error)
}

type SnapshotWriter interface {
	WriteState(*CounterState) error
}

type Watcher interface {
	Cancel()
}