core

type Core struct {
	// contains filtered or unexported fields
}

type Event struct {
	ID       ID
	Contents string
}

type ID struct {
	T      TS
	Expire TS
}

type Key struct {
	Base string
	Subs []string
}

type Opts struct {
	// Default 10. Number of threads which may publish simultaneously.
	NumPublishers int

	// Default "bananaq". String to prefix all redis keys with
	RedisPrefix string
}

type QueryAction struct {
	// Selects a set of IDs using various types of logic. See the doc on
	// QuerySelector for more. By default, a QuerySelector causes this
	// QueryAction to simply discard its input and output the QuerySelector's
	// output.
	*QuerySelector

	// Counts elements in a Key. See its doc string for more info
	*QueryCount

	// If true will count the number of IDs in the input to this action, append
	// that count to the result, and pass that input through as the output.
	CountInput bool

	// Adds the input IDs to the given Keys. See its doc string for more info
	*QueryAddTo

	// Removes IDs from Keys by score. See its doc string for more info
	*QueryRemoveByScore

	// Removes the input IDs from the given Keys
	RemoveFrom []Key

	// Adds an ID to a key. See its doc string for more info
	*QuerySingleSet

	// Retrieve an ID that was set at the given Key using SingleSet. The
	// output will be a set continaing only this ID, or empty output if the
	// key isn't set
	SingleGet *Key

	// Filters Events out of the input. See its doc string for more info
	*QueryFilter

	// Deletes whatever the Key's contents are. The input to this action becomes
	// the output
	Delete *Key

	// Stops the pipeline of QueryActions and returns the previous output
	Break bool

	// May be set alongside any of the other fields on this struct. See its doc
	// string for more info
	QueryConditional

	// Must be set alongside another field in this Selector. Indicates that
	// instead of discarding the output of the previous QueryAction, its output
	// and the output from this action should be merged as a union. That union
	// then becomes the output of this action.
	Union bool
}

type QueryActions struct {
	// This must match the Base field on all Keys being used in this pipeline
	KeyBase      string
	QueryActions []QueryAction

	// Optional, may be passed in if there is a previous notion of "current
	// time", to maintain consistency
	Now TS `msg:"-"`
}

type QueryAddTo struct {
	Keys          []Key
	ExpireAsScore bool
	Score         TS
}

type QueryConditional struct {
	// Only do the QueryAction if all of the conditionals in this list return
	// true
	And []QueryConditional

	// Only do the QueryAction if there is an empty input. Otherwise do no
	// action and pass the non-empty input through
	IfNoInput bool

	// Only do the QueryAction if there is non-empty input. Otherwise pass the
	// empty input through
	IfInput bool

	// Only do the QueryAction if the given Key has no data in it
	IfEmpty *Key

	// Only do the QueryAction if the given Key has data in it
	IfNotEmpty *Key
}

type QueryCount struct {
	Key
	QueryScoreRange
}

type QueryFilter struct {
	// If set, only IDs which have not expired will be allowed through
	Expired bool

	// May be set alongside any other filter field. Will invert the filter, so
	// that whatever IDs would have been allowed through will not be, and
	// vice-versa
	Invert bool
}

type QueryIDScoreSelect struct {
	ID    ID
	Min   TS
	Max   TS
	Equal TS
}

type QueryRangeSelect struct {
	QueryScoreRange

	// Optional modifiers. If Offset is nonzero, Limit must be nonzero too (it
	// can be -1 to indicate no limit)
	Limit, Offset int64

	// If true, reverses the order that IDs in the set are processed and
	// returned. The meanings of Min/Max stay the same though.
	Reverse bool
}

type QueryRemoveByScore struct {
	Keys []Key
	QueryScoreRange
}

type QueryRes struct {
	IDs    []ID
	Counts []uint64
}

type QueryScoreRange struct {
	Min              TS
	Max              TS
	MinExcl, MaxExcl bool

	// May be set instead of Min. The newest ID from the input to this
	// QueryAction will be used as the Min. If the input is empty, Min will be 0
	MinFromInput bool

	// May be set instead of Max. The oldest ID from the input to this
	// QueryAction will be used as the Max. If the input is empty, Max will be 0
	MaxFromInput bool
}

type QuerySelector struct {
	Key

	// See QueryRangeSelect doc string
	*QueryRangeSelect

	// See QueryIDScoreSelect doc string
	*QueryIDScoreSelect

	// Select IDs by their position within the Key, using a two element
	// slice. 0 is the oldest id, 1 is the second oldest, etc... -1 is the
	// youngest, -2 the second youngest, etc...
	PosRangeSelect []int64

	// Doesn't actually do a query, the output from this selector will simply be
	// these IDs.
	IDs []ID
}

type QuerySingleSet struct {
	Key
	IfNewer bool
}

type TS uint64