store

type Adapter interface {
	SegmentReader
	LinkWriter
	EvidenceStore

	// Returns arbitrary information about the adapter.
	GetInfo(ctx context.Context) (interface{}, error)

	// Adds a channel that receives events from the store.
	AddStoreEventChannel(chan *Event)

	// Creates a new Batch
	NewBatch(ctx context.Context) (Batch, error)
}

type Batch interface {
	SegmentReader
	LinkWriter

	// Write definitely writes the content of the Batch
	Write(ctx context.Context) error
}

type Event struct {
	EventType EventType
	Data      interface{}
}

type EventType string

type EvidenceReader interface {
	// Get the evidences for a segment.
	// Can return a nil error with an empty evidence slice if
	// the segment currently doesn't have evidence.
	GetEvidences(ctx context.Context, linkHash *types.Bytes32) (*cs.Evidences, error)
}

type EvidenceStore interface {
	EvidenceReader
	EvidenceWriter
}

type EvidenceWriter interface {
	// Add an evidence to a segment.
	AddEvidence(ctx context.Context, linkHash *types.Bytes32, evidence *cs.Evidence) error
}

type KeyValueReader interface {
	GetValue(ctx context.Context, key []byte) ([]byte, error)
}

type KeyValueStore interface {
	KeyValueReader
	KeyValueWriter
}

type KeyValueWriter interface {
	SetValue(ctx context.Context, key []byte, value []byte) error
	DeleteValue(ctx context.Context, key []byte) ([]byte, error)
}

type LinkWriter interface {
	// Create the immutable part of a segment.
	// The input link is expected to be valid.
	// Returns the link hash or an error.
	CreateLink(ctx context.Context, link *cs.Link) (*types.Bytes32, error)
}

type MapFilter struct {
	Pagination `json:"pagination"`

	// Process name is optionnal.
	Process string `json:"process" url:"-"`
}

type Pagination struct {
	// Index of the first entry.
	Offset int `json:"offset" url:"offset"`

	// Maximum number of entries.
	Limit int `json:"limit" url:"limit"`
}

type SegmentFilter struct {
	Pagination `json:"pagination"`

	// Map IDs the segments must have.
	MapIDs []string `json:"mapIds" url:"mapIds,brackets"`

	// Process name is optionnal.
	Process string `json:"process" url:"-"`

	// A previous link hash the segments must have.
	// nil makes this attribute as optional
	// empty string is to search Segments without parent
	PrevLinkHash *string `json:"prevLinkHash" url:"prevLinkHash"`

	// A slice of linkHashes to search Segments.
	// This attribute is optional.
	LinkHashes []string `json:"linkHashes" url:"linkHashes,brackets"`

	// A slice of tags the segments must all contain.
	Tags []string `json:"tags" url:"tags,brackets"`
}

type SegmentReader interface {
	// Get a segment by link hash. Returns nil if no match is found.
	// Will return link and evidences (if there are some in that store).
	GetSegment(ctx context.Context, linkHash *types.Bytes32) (*cs.Segment, error)

	// Find segments. Returns an empty slice if there are no results.
	// Will return links and evidences (if there are some).
	FindSegments(ctx context.Context, filter *SegmentFilter) (cs.SegmentSlice, error)

	// Get all the existing map IDs.
	GetMapIDs(ctx context.Context, filter *MapFilter) ([]string, error)
}