buffer

Documentation

Index

• type BlockingDeque
  • func NewUnboundedBlockingDeque[T any](initSize int) BlockingDeque[T]
• type Deque
  • func NewUnboundedDeque[T any](initSize int) Deque[T]
• type Queue
  • func NewBoundedQueue[T any](maxSize int, onEvict func(T)) (Queue[T], error)

Types

type BlockingDeque

type BlockingDeque[T any] interface {
	Deque[T]

	// Close and empty the deque.
	Close()
}

func NewUnboundedBlockingDeque

func NewUnboundedBlockingDeque[T any](initSize int) BlockingDeque[T]

Returns a new unbounded deque with the given initial size. Note that the returned deque is always empty -- [initSize] is just a hint to prevent unnecessary resizing.

type Deque

type Deque[T any] interface {
	// Place an element at the leftmost end of the deque.
	// Returns true if the element was placed in the deque.
	PushLeft(T) bool
	// Place an element at the rightmost end of the deque.
	// Returns true if the element was placed in the deque.
	PushRight(T) bool
	// Remove and return the leftmost element of the deque.
	// Returns false if the deque is empty.
	PopLeft() (T, bool)
	// Remove and return the rightmost element of the deque.
	// Returns false if the deque is empty.
	PopRight() (T, bool)
	// Return the leftmost element of the deque without removing it.
	// Returns false if the deque is empty.
	PeekLeft() (T, bool)
	// Return the rightmost element of the deque without removing it.
	// Returns false if the deque is empty.
	PeekRight() (T, bool)
	// Returns the element at the given index.
	// Returns false if the index is out of bounds.
	// The leftmost element is at index 0.
	Index(int) (T, bool)
	// Returns the number of elements in the deque.
	Len() int
	// Returns the elements in the deque from left to right.
	List() []T
}

An unbounded deque (double-ended queue). See https://en.wikipedia.org/wiki/Double-ended_queue Not safe for concurrent access.

func NewUnboundedDeque

func NewUnboundedDeque[T any](initSize int) Deque[T]

Returns a new unbounded deque with the given initial slice size. Note that the returned deque is always empty -- [initSize] is just a hint to prevent unnecessary resizing.

type Queue

type Queue[T any] interface {
	// Pushes [elt] onto the queue.
	// If the queue is full, the oldest element is evicted to make space.
	Push(T)
	// Pops the oldest element from the queue.
	// Returns false if the queue is empty.
	Pop() (T, bool)
	// Returns the oldest element without removing it.
	// Returns false if the queue is empty.
	Peek() (T, bool)
	// Returns the element at the given index without removing it.
	// Index(0) returns the oldest element.
	// Index(Len() - 1) returns the newest element.
	// Returns false if there is no element at that index.
	Index(int) (T, bool)
	// Returns the number of elements in the queue.
	Len() int
	// Returns the queue elements from oldest to newest.
	// This is an O(n) operation and should be used sparingly.
	List() []T
}

A FIFO queue.

func NewBoundedQueue

func NewBoundedQueue[T any](maxSize int, onEvict func(T)) (Queue[T], error)

Returns a new bounded, non-blocking queue that holds up to [maxSize] elements. When an element is evicted, [onEvict] is called with the evicted element. If [onEvict] is nil, this is a no-op. [maxSize] must be >= 1. Not safe for concurrent use.