fifoqueue

package
v0.25.11 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 19, 2022 License: AGPL-3.0 Imports: 4 Imported by: 10

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type ConstructorOption

type ConstructorOption func(*FifoQueue) error

ConstructorOptions are optional arguments for the `NewFifoQueue` constructor to specify properties of the FifoQueue.

func WithCapacity

func WithCapacity(capacity int) ConstructorOption

WithCapacity is a constructor option for NewFifoQueue. It specifies the max number of elements the queue can hold. By default, the theoretical capacity equals to the largest `int` value (platform dependent). The WithCapacity option overrides the previous value (default value or value specified by previous option).

func WithLengthObserver

func WithLengthObserver(callback QueueLengthObserver) ConstructorOption

WithLengthObserver is a constructor option for NewFifoQueue. Each time the queue's length changes, the queue calls the provided callback with the new length. By default, the QueueLengthObserver is a NoOp. CAUTION:

  • QueueLengthObserver implementations must be non-blocking
  • The values published to queue length observer might be in different order than the actual length values at the time of insertion. This is a performance optimization, which allows to reduce the duration during which the queue is internally locked when inserting elements.

type FifoQueue

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

FifoQueue implements a FIFO queue with max capacity and length observer. Elements that exceeds the queue's max capacity are silently dropped. By default, the theoretical capacity equals to the largest `int` value (platform dependent). Capacity can be set at construction time via the option `WithCapacity`. Each time the queue's length changes, the QueueLengthObserver is called with the new length. By default, the QueueLengthObserver is a NoOp. A single QueueLengthObserver can be set at construction time via the option `WithLengthObserver`.

Caution: * the QueueLengthObserver must be non-blocking

func NewFifoQueue

func NewFifoQueue(options ...ConstructorOption) (*FifoQueue, error)

NewFifoQueue is the Constructor for FifoQueue

func (*FifoQueue) Head

func (q *FifoQueue) Head() (interface{}, bool)

Front peeks message at the head of the queue (without removing the head).

func (*FifoQueue) Len

func (q *FifoQueue) Len() int

Len returns the current length of the queue.

func (*FifoQueue) Pop

func (q *FifoQueue) Pop() (interface{}, bool)

Pop removes and returns the queue's head element. If the queue is empty, (nil, false) is returned.

func (*FifoQueue) Push

func (q *FifoQueue) Push(element interface{}) bool

Push appends the given value to the tail of the queue. If queue capacity is reached, the message is silently dropped.

type QueueLengthObserver

type QueueLengthObserver func(int)

QueueLengthObserver is a optional callback that can be provided to the `NewFifoQueue` constructor (via `WithLengthObserver` option).

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL