fifoqueue

package
v0.34.0-crescendo-prev... Latest Latest
Warning

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

Go to latest
Published: Feb 22, 2024 License: AGPL-3.0 Imports: 4 Imported by: 10

Documentation

Index

Constants

View Source
const CapacityUnlimited = 1<<(mathbits.UintSize-1) - 1

CapacityUnlimited specifies the largest possible capacity for a FifoQueue. maximum value for platform-specific int: https://yourbasic.org/golang/max-min-int-uint/

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 WithLengthMetricObserver added in v0.31.0

func WithLengthMetricObserver(resource string, observe func(resource string, length uint)) ConstructorOption

WithLengthMetricObserver attaches a length observer which calls the given observe function. It can be used to concisely bind a metrics observer implementing module.MempoolMetrics to the queue.

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(maxCapacity int, 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