queue

type BroadcastEntry[T any] struct {
	Position uint64
	Value    T
}

type BroadcastQueue[T any] interface {
	// CloseSubscriber closes a subscriber channel.
	CloseSubscriber(<-chan BroadcastEntry[T])

	// IterateEntries will call fn for each entry in the queue, starting from
	// the front (oldest). If fn returns false the iteration terminates and
	// IterateEntries will return false, else it will return true.
	IterateEntries(fn func(BroadcastEntry[T]) bool) bool

	// IterateEntriesReverse will call fn for each entry in the queue, starting
	// from the back (newest). If fn returns false the iteration terminates and
	// IterateEntriesReverse will return false, else it will return true.
	IterateEntriesReverse(fn func(BroadcastEntry[T]) bool) bool

	// IterateValues will call fn for each entry in the queue, starting from
	// the front (oldest). If fn returns false the iteration terminates and
	// IterateValues will return false, else it will return true.
	IterateValues(fn func(T) bool) bool

	// IterateValuesReverse will call fn for each entry in the queue, starting
	// from the back (newest). If fn returns false the iteration terminates and
	// IterateEntriesReverse will return false, else it will return true.
	IterateValuesReverse(fn func(T) bool) bool

	// Position returns the position of the next entry that will be sent.
	Position() uint64

	// Subscribe creates a subscriber channel which will receive messages at the
	// specified startingPostion.
	Subscribe(startingPosition uint64) <-chan BroadcastEntry[T]

	// Sync ensures that any pending messages have been added to the queue.
	Sync()
}

type CloseSender[T any] interface {
	Closer
	Sender[T]
}

type Closer interface {
	Close()
}

type LengthRecorder func(uint)

type Queue[T any] interface {
	Receiver[T]
	Sender[T]
}

type Receiver[T any] interface {
	Receive() (T, bool)
	ReceiveAll() []T
}

type Sender[T any] interface {
	Send(value T)
}