indexedmap

type ClearProposal interface {
	Proposal
	Request() *indexedmap.ClearRequest
}

type ClearProposals interface {
	Get(ProposalID) (ClearProposal, bool)
	List() []ClearProposal
}

type EntriesQuery interface {
	Query
	Request() *indexedmap.EntriesRequest
	Notify(*indexedmap.EntriesResponse)
	Close()
}

type EventsProposal interface {
	Proposal
	Request() *indexedmap.EventsRequest
	Notify(*indexedmap.EventsResponse)
	Close()
}

type EventsProposals interface {
	Get(ProposalID) (EventsProposal, bool)
	List() []EventsProposal
}

type FirstEntryQuery interface {
	Query
	Request() *indexedmap.FirstEntryRequest
}

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

type IndexedMapEntry struct {
	IndexedMapEntryPosition `protobuf:"bytes,1,opt,name=pos,proto3,embedded=pos" json:"pos"`
	IndexedMapEntryValue    `protobuf:"bytes,2,opt,name=value,proto3,embedded=value" json:"value"`
}

type IndexedMapEntryPosition struct {
	Index uint64 `protobuf:"varint,1,opt,name=index,proto3" json:"index,omitempty"`
	Key   string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
}

type IndexedMapEntryValue struct {
	meta.ObjectMeta `protobuf:"bytes,1,opt,name=meta,proto3,embedded=meta" json:"meta"`
	Value           []byte     `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	Expire          *time.Time `protobuf:"bytes,3,opt,name=expire,proto3,stdtime" json:"expire,omitempty"`
}

type IndexedMapState struct {
	Listeners []IndexedMapStateListener `protobuf:"bytes,1,rep,name=listeners,proto3" json:"listeners"`
	Entries   []IndexedMapEntry         `protobuf:"bytes,2,rep,name=entries,proto3" json:"entries"`
}

type IndexedMapStateListener struct {
	ProposalID ProposalID `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3,casttype=ProposalID" json:"proposal_id,omitempty"`
	Key        string     `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	Index      uint64     `protobuf:"varint,3,opt,name=index,proto3" json:"index,omitempty"`
}

type LastEntryQuery interface {
	Query
	Request() *indexedmap.LastEntryRequest
}

type LinkedMapEntryValue struct {
	*IndexedMapEntry
	Prev *LinkedMapEntryValue
	Next *LinkedMapEntryValue
}

type NewServiceFunc func(ServiceContext) Service

type NextEntryQuery interface {
	Query
	Request() *indexedmap.NextEntryRequest
}

type PrevEntryQuery interface {
	Query
	Request() *indexedmap.PrevEntryRequest
}

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

type ProposalID uint64

type ProposalState int

type Proposals interface {
	Put() PutProposals
	Remove() RemoveProposals
	Clear() ClearProposals
	Events() EventsProposals
}

type PutProposal interface {
	Proposal
	Request() *indexedmap.PutRequest
}

type PutProposals interface {
	Get(ProposalID) (PutProposal, bool)
	List() []PutProposal
}

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

type RemoveProposal interface {
	Proposal
	Request() *indexedmap.RemoveRequest
}

type RemoveProposals interface {
	Get(ProposalID) (RemoveProposal, bool)
	List() []RemoveProposal
}

type Service interface {
	ServiceContext
	Backup(SnapshotWriter) error
	Restore(SnapshotReader) error
	// Size returns the size of the map
	Size(SizeQuery) (*indexedmap.SizeResponse, error)
	// Put puts an entry into the map
	Put(PutProposal) (*indexedmap.PutResponse, error)
	// Get gets the entry for a key
	Get(GetQuery) (*indexedmap.GetResponse, error)
	// FirstEntry gets the first entry in the map
	FirstEntry(FirstEntryQuery) (*indexedmap.FirstEntryResponse, error)
	// LastEntry gets the last entry in the map
	LastEntry(LastEntryQuery) (*indexedmap.LastEntryResponse, error)
	// PrevEntry gets the previous entry in the map
	PrevEntry(PrevEntryQuery) (*indexedmap.PrevEntryResponse, error)
	// NextEntry gets the next entry in the map
	NextEntry(NextEntryQuery) (*indexedmap.NextEntryResponse, error)
	// Remove removes an entry from the map
	Remove(RemoveProposal) (*indexedmap.RemoveResponse, error)
	// Clear removes all entries from the map
	Clear(ClearProposal) (*indexedmap.ClearResponse, error)
	// Events listens for change events
	Events(EventsProposal)
	// Entries lists all entries in the map
	Entries(EntriesQuery)
}

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 SizeQuery interface {
	Query
	Request() *indexedmap.SizeRequest
}

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

type SnapshotWriter interface {
	WriteState(*IndexedMapState) error
}

type Watcher interface {
	Cancel()
}