node

package
v2.3.0 Latest Latest
Warning

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

 Go to latest Published: Dec 22, 2025 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Overview

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated by the generator.

Package node is a generated generator package.

Index

Constants

View Source 
const (
	InWindowQueue uint8 = iota
	InMainProbationQueue
	InMainProtectedQueue
)

Variables

This section is empty.

Functions

func Equals 

func Equals[K comparable, V any](a, b Node[K, V]) bool

Types

type B 

type B[K comparable, V any] struct {
	// contains filtered or unexported fields
}

B is a cache entry that provide the following features:

1. Base

func (*B[K, V]) AsPointer 

func (n *B[K, V]) AsPointer() unsafe.Pointer

func (*B[K, V]) CASExpiresAt 

func (n *B[K, V]) CASExpiresAt(old, new int64) bool

func (*B[K, V]) CASRefreshableAt 

func (n *B[K, V]) CASRefreshableAt(old, new int64) bool

func (*B[K, V]) Die 

func (n *B[K, V]) Die()

func (*B[K, V]) ExpiresAt 

func (n *B[K, V]) ExpiresAt() int64

func (*B[K, V]) GetQueueType 

func (n *B[K, V]) GetQueueType() uint8

func (*B[K, V]) HasExpired 

func (n *B[K, V]) HasExpired(now int64) bool

func (*B[K, V]) InMainProbation 

func (n *B[K, V]) InMainProbation() bool

func (*B[K, V]) InMainProtected 

func (n *B[K, V]) InMainProtected() bool

func (*B[K, V]) InWindow 

func (n *B[K, V]) InWindow() bool

func (*B[K, V]) IsAlive 

func (n *B[K, V]) IsAlive() bool

func (*B[K, V]) IsDead 

func (n *B[K, V]) IsDead() bool

func (*B[K, V]) IsFresh 

func (n *B[K, V]) IsFresh(now int64) bool

func (*B[K, V]) IsRetired 

func (n *B[K, V]) IsRetired() bool

func (*B[K, V]) Key 

func (n *B[K, V]) Key() K

func (*B[K, V]) MakeMainProbation 

func (n *B[K, V]) MakeMainProbation()

func (*B[K, V]) MakeMainProtected 

func (n *B[K, V]) MakeMainProtected()

func (*B[K, V]) MakeWindow 

func (n *B[K, V]) MakeWindow()

func (*B[K, V]) Next 

func (n *B[K, V]) Next() Node[K, V]

func (*B[K, V]) NextExp 

func (n *B[K, V]) NextExp() Node[K, V]

func (*B[K, V]) Prev 

func (n *B[K, V]) Prev() Node[K, V]

func (*B[K, V]) PrevExp 

func (n *B[K, V]) PrevExp() Node[K, V]

func (*B[K, V]) RefreshableAt 

func (n *B[K, V]) RefreshableAt() int64

func (*B[K, V]) Retire 

func (n *B[K, V]) Retire()

func (*B[K, V]) SetExpiresAt 

func (n *B[K, V]) SetExpiresAt(new int64)

func (*B[K, V]) SetNext 

func (n *B[K, V]) SetNext(v Node[K, V])

func (*B[K, V]) SetNextExp 

func (n *B[K, V]) SetNextExp(v Node[K, V])

func (*B[K, V]) SetPrev 

func (n *B[K, V]) SetPrev(v Node[K, V])

func (*B[K, V]) SetPrevExp 

func (n *B[K, V]) SetPrevExp(v Node[K, V])

func (*B[K, V]) SetQueueType 

func (n *B[K, V]) SetQueueType(queueType uint8)

func (*B[K, V]) SetRefreshableAt 

func (n *B[K, V]) SetRefreshableAt(new int64)

func (*B[K, V]) Value 

func (n *B[K, V]) Value() V

func (*B[K, V]) Weight 

func (n *B[K, V]) Weight() uint32

type BE 

type BE[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BE is a cache entry that provide the following features:

1. Base

2. Expiration

func (*BE[K, V]) AsPointer 

func (n *BE[K, V]) AsPointer() unsafe.Pointer

func (*BE[K, V]) CASExpiresAt 

func (n *BE[K, V]) CASExpiresAt(old, new int64) bool

func (*BE[K, V]) CASRefreshableAt 

func (n *BE[K, V]) CASRefreshableAt(old, new int64) bool

func (*BE[K, V]) Die 

func (n *BE[K, V]) Die()

func (*BE[K, V]) ExpiresAt 

func (n *BE[K, V]) ExpiresAt() int64

func (*BE[K, V]) GetQueueType 

func (n *BE[K, V]) GetQueueType() uint8

func (*BE[K, V]) HasExpired 

func (n *BE[K, V]) HasExpired(now int64) bool

func (*BE[K, V]) InMainProbation 

func (n *BE[K, V]) InMainProbation() bool

func (*BE[K, V]) InMainProtected 

func (n *BE[K, V]) InMainProtected() bool

func (*BE[K, V]) InWindow 

func (n *BE[K, V]) InWindow() bool

func (*BE[K, V]) IsAlive 

func (n *BE[K, V]) IsAlive() bool

func (*BE[K, V]) IsDead 

func (n *BE[K, V]) IsDead() bool

func (*BE[K, V]) IsFresh 

func (n *BE[K, V]) IsFresh(now int64) bool

func (*BE[K, V]) IsRetired 

func (n *BE[K, V]) IsRetired() bool

func (*BE[K, V]) Key 

func (n *BE[K, V]) Key() K

func (*BE[K, V]) MakeMainProbation 

func (n *BE[K, V]) MakeMainProbation()

func (*BE[K, V]) MakeMainProtected 

func (n *BE[K, V]) MakeMainProtected()

func (*BE[K, V]) MakeWindow 

func (n *BE[K, V]) MakeWindow()

func (*BE[K, V]) Next 

func (n *BE[K, V]) Next() Node[K, V]

func (*BE[K, V]) NextExp 

func (n *BE[K, V]) NextExp() Node[K, V]

func (*BE[K, V]) Prev 

func (n *BE[K, V]) Prev() Node[K, V]

func (*BE[K, V]) PrevExp 

func (n *BE[K, V]) PrevExp() Node[K, V]

func (*BE[K, V]) RefreshableAt 

func (n *BE[K, V]) RefreshableAt() int64

func (*BE[K, V]) Retire 

func (n *BE[K, V]) Retire()

func (*BE[K, V]) SetExpiresAt 

func (n *BE[K, V]) SetExpiresAt(new int64)

func (*BE[K, V]) SetNext 

func (n *BE[K, V]) SetNext(v Node[K, V])

func (*BE[K, V]) SetNextExp 

func (n *BE[K, V]) SetNextExp(v Node[K, V])

func (*BE[K, V]) SetPrev 

func (n *BE[K, V]) SetPrev(v Node[K, V])

func (*BE[K, V]) SetPrevExp 

func (n *BE[K, V]) SetPrevExp(v Node[K, V])

func (*BE[K, V]) SetQueueType 

func (n *BE[K, V]) SetQueueType(queueType uint8)

func (*BE[K, V]) SetRefreshableAt 

func (n *BE[K, V]) SetRefreshableAt(new int64)

func (*BE[K, V]) Value 

func (n *BE[K, V]) Value() V

func (*BE[K, V]) Weight 

func (n *BE[K, V]) Weight() uint32

type BER 

type BER[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BER is a cache entry that provide the following features:

1. Base

2. Expiration

3. Refresh

func (*BER[K, V]) AsPointer 

func (n *BER[K, V]) AsPointer() unsafe.Pointer

func (*BER[K, V]) CASExpiresAt 

func (n *BER[K, V]) CASExpiresAt(old, new int64) bool

func (*BER[K, V]) CASRefreshableAt 

func (n *BER[K, V]) CASRefreshableAt(old, new int64) bool

func (*BER[K, V]) Die 

func (n *BER[K, V]) Die()

func (*BER[K, V]) ExpiresAt 

func (n *BER[K, V]) ExpiresAt() int64

func (*BER[K, V]) GetQueueType 

func (n *BER[K, V]) GetQueueType() uint8

func (*BER[K, V]) HasExpired 

func (n *BER[K, V]) HasExpired(now int64) bool

func (*BER[K, V]) InMainProbation 

func (n *BER[K, V]) InMainProbation() bool

func (*BER[K, V]) InMainProtected 

func (n *BER[K, V]) InMainProtected() bool

func (*BER[K, V]) InWindow 

func (n *BER[K, V]) InWindow() bool

func (*BER[K, V]) IsAlive 

func (n *BER[K, V]) IsAlive() bool

func (*BER[K, V]) IsDead 

func (n *BER[K, V]) IsDead() bool

func (*BER[K, V]) IsFresh 

func (n *BER[K, V]) IsFresh(now int64) bool

func (*BER[K, V]) IsRetired 

func (n *BER[K, V]) IsRetired() bool

func (*BER[K, V]) Key 

func (n *BER[K, V]) Key() K

func (*BER[K, V]) MakeMainProbation 

func (n *BER[K, V]) MakeMainProbation()

func (*BER[K, V]) MakeMainProtected 

func (n *BER[K, V]) MakeMainProtected()

func (*BER[K, V]) MakeWindow 

func (n *BER[K, V]) MakeWindow()

func (*BER[K, V]) Next 

func (n *BER[K, V]) Next() Node[K, V]

func (*BER[K, V]) NextExp 

func (n *BER[K, V]) NextExp() Node[K, V]

func (*BER[K, V]) Prev 

func (n *BER[K, V]) Prev() Node[K, V]

func (*BER[K, V]) PrevExp 

func (n *BER[K, V]) PrevExp() Node[K, V]

func (*BER[K, V]) RefreshableAt 

func (n *BER[K, V]) RefreshableAt() int64

func (*BER[K, V]) Retire 

func (n *BER[K, V]) Retire()

func (*BER[K, V]) SetExpiresAt 

func (n *BER[K, V]) SetExpiresAt(new int64)

func (*BER[K, V]) SetNext 

func (n *BER[K, V]) SetNext(v Node[K, V])

func (*BER[K, V]) SetNextExp 

func (n *BER[K, V]) SetNextExp(v Node[K, V])

func (*BER[K, V]) SetPrev 

func (n *BER[K, V]) SetPrev(v Node[K, V])

func (*BER[K, V]) SetPrevExp 

func (n *BER[K, V]) SetPrevExp(v Node[K, V])

func (*BER[K, V]) SetQueueType 

func (n *BER[K, V]) SetQueueType(queueType uint8)

func (*BER[K, V]) SetRefreshableAt 

func (n *BER[K, V]) SetRefreshableAt(new int64)

func (*BER[K, V]) Value 

func (n *BER[K, V]) Value() V

func (*BER[K, V]) Weight 

func (n *BER[K, V]) Weight() uint32

type BERW 

type BERW[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BERW is a cache entry that provide the following features:

1. Base

2. Expiration

3. Refresh

4. Weight

func (*BERW[K, V]) AsPointer 

func (n *BERW[K, V]) AsPointer() unsafe.Pointer

func (*BERW[K, V]) CASExpiresAt 

func (n *BERW[K, V]) CASExpiresAt(old, new int64) bool

func (*BERW[K, V]) CASRefreshableAt 

func (n *BERW[K, V]) CASRefreshableAt(old, new int64) bool

func (*BERW[K, V]) Die 

func (n *BERW[K, V]) Die()

func (*BERW[K, V]) ExpiresAt 

func (n *BERW[K, V]) ExpiresAt() int64

func (*BERW[K, V]) GetQueueType 

func (n *BERW[K, V]) GetQueueType() uint8

func (*BERW[K, V]) HasExpired 

func (n *BERW[K, V]) HasExpired(now int64) bool

func (*BERW[K, V]) InMainProbation 

func (n *BERW[K, V]) InMainProbation() bool

func (*BERW[K, V]) InMainProtected 

func (n *BERW[K, V]) InMainProtected() bool

func (*BERW[K, V]) InWindow 

func (n *BERW[K, V]) InWindow() bool

func (*BERW[K, V]) IsAlive 

func (n *BERW[K, V]) IsAlive() bool

func (*BERW[K, V]) IsDead 

func (n *BERW[K, V]) IsDead() bool

func (*BERW[K, V]) IsFresh 

func (n *BERW[K, V]) IsFresh(now int64) bool

func (*BERW[K, V]) IsRetired 

func (n *BERW[K, V]) IsRetired() bool

func (*BERW[K, V]) Key 

func (n *BERW[K, V]) Key() K

func (*BERW[K, V]) MakeMainProbation 

func (n *BERW[K, V]) MakeMainProbation()

func (*BERW[K, V]) MakeMainProtected 

func (n *BERW[K, V]) MakeMainProtected()

func (*BERW[K, V]) MakeWindow 

func (n *BERW[K, V]) MakeWindow()

func (*BERW[K, V]) Next 

func (n *BERW[K, V]) Next() Node[K, V]

func (*BERW[K, V]) NextExp 

func (n *BERW[K, V]) NextExp() Node[K, V]

func (*BERW[K, V]) Prev 

func (n *BERW[K, V]) Prev() Node[K, V]

func (*BERW[K, V]) PrevExp 

func (n *BERW[K, V]) PrevExp() Node[K, V]

func (*BERW[K, V]) RefreshableAt 

func (n *BERW[K, V]) RefreshableAt() int64

func (*BERW[K, V]) Retire 

func (n *BERW[K, V]) Retire()

func (*BERW[K, V]) SetExpiresAt 

func (n *BERW[K, V]) SetExpiresAt(new int64)

func (*BERW[K, V]) SetNext 

func (n *BERW[K, V]) SetNext(v Node[K, V])

func (*BERW[K, V]) SetNextExp 

func (n *BERW[K, V]) SetNextExp(v Node[K, V])

func (*BERW[K, V]) SetPrev 

func (n *BERW[K, V]) SetPrev(v Node[K, V])

func (*BERW[K, V]) SetPrevExp 

func (n *BERW[K, V]) SetPrevExp(v Node[K, V])

func (*BERW[K, V]) SetQueueType 

func (n *BERW[K, V]) SetQueueType(queueType uint8)

func (*BERW[K, V]) SetRefreshableAt 

func (n *BERW[K, V]) SetRefreshableAt(new int64)

func (*BERW[K, V]) Value 

func (n *BERW[K, V]) Value() V

func (*BERW[K, V]) Weight 

func (n *BERW[K, V]) Weight() uint32

type BEW 

type BEW[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BEW is a cache entry that provide the following features:

1. Base

2. Expiration

3. Weight

func (*BEW[K, V]) AsPointer 

func (n *BEW[K, V]) AsPointer() unsafe.Pointer

func (*BEW[K, V]) CASExpiresAt 

func (n *BEW[K, V]) CASExpiresAt(old, new int64) bool

func (*BEW[K, V]) CASRefreshableAt 

func (n *BEW[K, V]) CASRefreshableAt(old, new int64) bool

func (*BEW[K, V]) Die 

func (n *BEW[K, V]) Die()

func (*BEW[K, V]) ExpiresAt 

func (n *BEW[K, V]) ExpiresAt() int64

func (*BEW[K, V]) GetQueueType 

func (n *BEW[K, V]) GetQueueType() uint8

func (*BEW[K, V]) HasExpired 

func (n *BEW[K, V]) HasExpired(now int64) bool

func (*BEW[K, V]) InMainProbation 

func (n *BEW[K, V]) InMainProbation() bool

func (*BEW[K, V]) InMainProtected 

func (n *BEW[K, V]) InMainProtected() bool

func (*BEW[K, V]) InWindow 

func (n *BEW[K, V]) InWindow() bool

func (*BEW[K, V]) IsAlive 

func (n *BEW[K, V]) IsAlive() bool

func (*BEW[K, V]) IsDead 

func (n *BEW[K, V]) IsDead() bool

func (*BEW[K, V]) IsFresh 

func (n *BEW[K, V]) IsFresh(now int64) bool

func (*BEW[K, V]) IsRetired 

func (n *BEW[K, V]) IsRetired() bool

func (*BEW[K, V]) Key 

func (n *BEW[K, V]) Key() K

func (*BEW[K, V]) MakeMainProbation 

func (n *BEW[K, V]) MakeMainProbation()

func (*BEW[K, V]) MakeMainProtected 

func (n *BEW[K, V]) MakeMainProtected()

func (*BEW[K, V]) MakeWindow 

func (n *BEW[K, V]) MakeWindow()

func (*BEW[K, V]) Next 

func (n *BEW[K, V]) Next() Node[K, V]

func (*BEW[K, V]) NextExp 

func (n *BEW[K, V]) NextExp() Node[K, V]

func (*BEW[K, V]) Prev 

func (n *BEW[K, V]) Prev() Node[K, V]

func (*BEW[K, V]) PrevExp 

func (n *BEW[K, V]) PrevExp() Node[K, V]

func (*BEW[K, V]) RefreshableAt 

func (n *BEW[K, V]) RefreshableAt() int64

func (*BEW[K, V]) Retire 

func (n *BEW[K, V]) Retire()

func (*BEW[K, V]) SetExpiresAt 

func (n *BEW[K, V]) SetExpiresAt(new int64)

func (*BEW[K, V]) SetNext 

func (n *BEW[K, V]) SetNext(v Node[K, V])

func (*BEW[K, V]) SetNextExp 

func (n *BEW[K, V]) SetNextExp(v Node[K, V])

func (*BEW[K, V]) SetPrev 

func (n *BEW[K, V]) SetPrev(v Node[K, V])

func (*BEW[K, V]) SetPrevExp 

func (n *BEW[K, V]) SetPrevExp(v Node[K, V])

func (*BEW[K, V]) SetQueueType 

func (n *BEW[K, V]) SetQueueType(queueType uint8)

func (*BEW[K, V]) SetRefreshableAt 

func (n *BEW[K, V]) SetRefreshableAt(new int64)

func (*BEW[K, V]) Value 

func (n *BEW[K, V]) Value() V

func (*BEW[K, V]) Weight 

func (n *BEW[K, V]) Weight() uint32

type BR 

type BR[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BR is a cache entry that provide the following features:

1. Base

2. Refresh

func (*BR[K, V]) AsPointer 

func (n *BR[K, V]) AsPointer() unsafe.Pointer

func (*BR[K, V]) CASExpiresAt 

func (n *BR[K, V]) CASExpiresAt(old, new int64) bool

func (*BR[K, V]) CASRefreshableAt 

func (n *BR[K, V]) CASRefreshableAt(old, new int64) bool

func (*BR[K, V]) Die 

func (n *BR[K, V]) Die()

func (*BR[K, V]) ExpiresAt 

func (n *BR[K, V]) ExpiresAt() int64

func (*BR[K, V]) GetQueueType 

func (n *BR[K, V]) GetQueueType() uint8

func (*BR[K, V]) HasExpired 

func (n *BR[K, V]) HasExpired(now int64) bool

func (*BR[K, V]) InMainProbation 

func (n *BR[K, V]) InMainProbation() bool

func (*BR[K, V]) InMainProtected 

func (n *BR[K, V]) InMainProtected() bool

func (*BR[K, V]) InWindow 

func (n *BR[K, V]) InWindow() bool

func (*BR[K, V]) IsAlive 

func (n *BR[K, V]) IsAlive() bool

func (*BR[K, V]) IsDead 

func (n *BR[K, V]) IsDead() bool

func (*BR[K, V]) IsFresh 

func (n *BR[K, V]) IsFresh(now int64) bool

func (*BR[K, V]) IsRetired 

func (n *BR[K, V]) IsRetired() bool

func (*BR[K, V]) Key 

func (n *BR[K, V]) Key() K

func (*BR[K, V]) MakeMainProbation 

func (n *BR[K, V]) MakeMainProbation()

func (*BR[K, V]) MakeMainProtected 

func (n *BR[K, V]) MakeMainProtected()

func (*BR[K, V]) MakeWindow 

func (n *BR[K, V]) MakeWindow()

func (*BR[K, V]) Next 

func (n *BR[K, V]) Next() Node[K, V]

func (*BR[K, V]) NextExp 

func (n *BR[K, V]) NextExp() Node[K, V]

func (*BR[K, V]) Prev 

func (n *BR[K, V]) Prev() Node[K, V]

func (*BR[K, V]) PrevExp 

func (n *BR[K, V]) PrevExp() Node[K, V]

func (*BR[K, V]) RefreshableAt 

func (n *BR[K, V]) RefreshableAt() int64

func (*BR[K, V]) Retire 

func (n *BR[K, V]) Retire()

func (*BR[K, V]) SetExpiresAt 

func (n *BR[K, V]) SetExpiresAt(new int64)

func (*BR[K, V]) SetNext 

func (n *BR[K, V]) SetNext(v Node[K, V])

func (*BR[K, V]) SetNextExp 

func (n *BR[K, V]) SetNextExp(v Node[K, V])

func (*BR[K, V]) SetPrev 

func (n *BR[K, V]) SetPrev(v Node[K, V])

func (*BR[K, V]) SetPrevExp 

func (n *BR[K, V]) SetPrevExp(v Node[K, V])

func (*BR[K, V]) SetQueueType 

func (n *BR[K, V]) SetQueueType(queueType uint8)

func (*BR[K, V]) SetRefreshableAt 

func (n *BR[K, V]) SetRefreshableAt(new int64)

func (*BR[K, V]) Value 

func (n *BR[K, V]) Value() V

func (*BR[K, V]) Weight 

func (n *BR[K, V]) Weight() uint32

type BRW 

type BRW[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BRW is a cache entry that provide the following features:

1. Base

2. Refresh

3. Weight

func (*BRW[K, V]) AsPointer 

func (n *BRW[K, V]) AsPointer() unsafe.Pointer

func (*BRW[K, V]) CASExpiresAt 

func (n *BRW[K, V]) CASExpiresAt(old, new int64) bool

func (*BRW[K, V]) CASRefreshableAt 

func (n *BRW[K, V]) CASRefreshableAt(old, new int64) bool

func (*BRW[K, V]) Die 

func (n *BRW[K, V]) Die()

func (*BRW[K, V]) ExpiresAt 

func (n *BRW[K, V]) ExpiresAt() int64

func (*BRW[K, V]) GetQueueType 

func (n *BRW[K, V]) GetQueueType() uint8

func (*BRW[K, V]) HasExpired 

func (n *BRW[K, V]) HasExpired(now int64) bool

func (*BRW[K, V]) InMainProbation 

func (n *BRW[K, V]) InMainProbation() bool

func (*BRW[K, V]) InMainProtected 

func (n *BRW[K, V]) InMainProtected() bool

func (*BRW[K, V]) InWindow 

func (n *BRW[K, V]) InWindow() bool

func (*BRW[K, V]) IsAlive 

func (n *BRW[K, V]) IsAlive() bool

func (*BRW[K, V]) IsDead 

func (n *BRW[K, V]) IsDead() bool

func (*BRW[K, V]) IsFresh 

func (n *BRW[K, V]) IsFresh(now int64) bool

func (*BRW[K, V]) IsRetired 

func (n *BRW[K, V]) IsRetired() bool

func (*BRW[K, V]) Key 

func (n *BRW[K, V]) Key() K

func (*BRW[K, V]) MakeMainProbation 

func (n *BRW[K, V]) MakeMainProbation()

func (*BRW[K, V]) MakeMainProtected 

func (n *BRW[K, V]) MakeMainProtected()

func (*BRW[K, V]) MakeWindow 

func (n *BRW[K, V]) MakeWindow()

func (*BRW[K, V]) Next 

func (n *BRW[K, V]) Next() Node[K, V]

func (*BRW[K, V]) NextExp 

func (n *BRW[K, V]) NextExp() Node[K, V]

func (*BRW[K, V]) Prev 

func (n *BRW[K, V]) Prev() Node[K, V]

func (*BRW[K, V]) PrevExp 

func (n *BRW[K, V]) PrevExp() Node[K, V]

func (*BRW[K, V]) RefreshableAt 

func (n *BRW[K, V]) RefreshableAt() int64

func (*BRW[K, V]) Retire 

func (n *BRW[K, V]) Retire()

func (*BRW[K, V]) SetExpiresAt 

func (n *BRW[K, V]) SetExpiresAt(new int64)

func (*BRW[K, V]) SetNext 

func (n *BRW[K, V]) SetNext(v Node[K, V])

func (*BRW[K, V]) SetNextExp 

func (n *BRW[K, V]) SetNextExp(v Node[K, V])

func (*BRW[K, V]) SetPrev 

func (n *BRW[K, V]) SetPrev(v Node[K, V])

func (*BRW[K, V]) SetPrevExp 

func (n *BRW[K, V]) SetPrevExp(v Node[K, V])

func (*BRW[K, V]) SetQueueType 

func (n *BRW[K, V]) SetQueueType(queueType uint8)

func (*BRW[K, V]) SetRefreshableAt 

func (n *BRW[K, V]) SetRefreshableAt(new int64)

func (*BRW[K, V]) Value 

func (n *BRW[K, V]) Value() V

func (*BRW[K, V]) Weight 

func (n *BRW[K, V]) Weight() uint32

type BS 

type BS[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BS is a cache entry that provide the following features:

1. Base

2. Size

func (*BS[K, V]) AsPointer 

func (n *BS[K, V]) AsPointer() unsafe.Pointer

func (*BS[K, V]) CASExpiresAt 

func (n *BS[K, V]) CASExpiresAt(old, new int64) bool

func (*BS[K, V]) CASRefreshableAt 

func (n *BS[K, V]) CASRefreshableAt(old, new int64) bool

func (*BS[K, V]) Die 

func (n *BS[K, V]) Die()

func (*BS[K, V]) ExpiresAt 

func (n *BS[K, V]) ExpiresAt() int64

func (*BS[K, V]) GetQueueType 

func (n *BS[K, V]) GetQueueType() uint8

func (*BS[K, V]) HasExpired 

func (n *BS[K, V]) HasExpired(now int64) bool

func (*BS[K, V]) InMainProbation 

func (n *BS[K, V]) InMainProbation() bool

func (*BS[K, V]) InMainProtected 

func (n *BS[K, V]) InMainProtected() bool

func (*BS[K, V]) InWindow 

func (n *BS[K, V]) InWindow() bool

func (*BS[K, V]) IsAlive 

func (n *BS[K, V]) IsAlive() bool

func (*BS[K, V]) IsDead 

func (n *BS[K, V]) IsDead() bool

func (*BS[K, V]) IsFresh 

func (n *BS[K, V]) IsFresh(now int64) bool

func (*BS[K, V]) IsRetired 

func (n *BS[K, V]) IsRetired() bool

func (*BS[K, V]) Key 

func (n *BS[K, V]) Key() K

func (*BS[K, V]) MakeMainProbation 

func (n *BS[K, V]) MakeMainProbation()

func (*BS[K, V]) MakeMainProtected 

func (n *BS[K, V]) MakeMainProtected()

func (*BS[K, V]) MakeWindow 

func (n *BS[K, V]) MakeWindow()

func (*BS[K, V]) Next 

func (n *BS[K, V]) Next() Node[K, V]

func (*BS[K, V]) NextExp 

func (n *BS[K, V]) NextExp() Node[K, V]

func (*BS[K, V]) Prev 

func (n *BS[K, V]) Prev() Node[K, V]

func (*BS[K, V]) PrevExp 

func (n *BS[K, V]) PrevExp() Node[K, V]

func (*BS[K, V]) RefreshableAt 

func (n *BS[K, V]) RefreshableAt() int64

func (*BS[K, V]) Retire 

func (n *BS[K, V]) Retire()

func (*BS[K, V]) SetExpiresAt 

func (n *BS[K, V]) SetExpiresAt(new int64)

func (*BS[K, V]) SetNext 

func (n *BS[K, V]) SetNext(v Node[K, V])

func (*BS[K, V]) SetNextExp 

func (n *BS[K, V]) SetNextExp(v Node[K, V])

func (*BS[K, V]) SetPrev 

func (n *BS[K, V]) SetPrev(v Node[K, V])

func (*BS[K, V]) SetPrevExp 

func (n *BS[K, V]) SetPrevExp(v Node[K, V])

func (*BS[K, V]) SetQueueType 

func (n *BS[K, V]) SetQueueType(queueType uint8)

func (*BS[K, V]) SetRefreshableAt 

func (n *BS[K, V]) SetRefreshableAt(new int64)

func (*BS[K, V]) Value 

func (n *BS[K, V]) Value() V

func (*BS[K, V]) Weight 

func (n *BS[K, V]) Weight() uint32

type BSE 

type BSE[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BSE is a cache entry that provide the following features:

1. Base

2. Size

3. Expiration

func (*BSE[K, V]) AsPointer 

func (n *BSE[K, V]) AsPointer() unsafe.Pointer

func (*BSE[K, V]) CASExpiresAt 

func (n *BSE[K, V]) CASExpiresAt(old, new int64) bool

func (*BSE[K, V]) CASRefreshableAt 

func (n *BSE[K, V]) CASRefreshableAt(old, new int64) bool

func (*BSE[K, V]) Die 

func (n *BSE[K, V]) Die()

func (*BSE[K, V]) ExpiresAt 

func (n *BSE[K, V]) ExpiresAt() int64

func (*BSE[K, V]) GetQueueType 

func (n *BSE[K, V]) GetQueueType() uint8

func (*BSE[K, V]) HasExpired 

func (n *BSE[K, V]) HasExpired(now int64) bool

func (*BSE[K, V]) InMainProbation 

func (n *BSE[K, V]) InMainProbation() bool

func (*BSE[K, V]) InMainProtected 

func (n *BSE[K, V]) InMainProtected() bool

func (*BSE[K, V]) InWindow 

func (n *BSE[K, V]) InWindow() bool

func (*BSE[K, V]) IsAlive 

func (n *BSE[K, V]) IsAlive() bool

func (*BSE[K, V]) IsDead 

func (n *BSE[K, V]) IsDead() bool

func (*BSE[K, V]) IsFresh 

func (n *BSE[K, V]) IsFresh(now int64) bool

func (*BSE[K, V]) IsRetired 

func (n *BSE[K, V]) IsRetired() bool

func (*BSE[K, V]) Key 

func (n *BSE[K, V]) Key() K

func (*BSE[K, V]) MakeMainProbation 

func (n *BSE[K, V]) MakeMainProbation()

func (*BSE[K, V]) MakeMainProtected 

func (n *BSE[K, V]) MakeMainProtected()

func (*BSE[K, V]) MakeWindow 

func (n *BSE[K, V]) MakeWindow()

func (*BSE[K, V]) Next 

func (n *BSE[K, V]) Next() Node[K, V]

func (*BSE[K, V]) NextExp 

func (n *BSE[K, V]) NextExp() Node[K, V]

func (*BSE[K, V]) Prev 

func (n *BSE[K, V]) Prev() Node[K, V]

func (*BSE[K, V]) PrevExp 

func (n *BSE[K, V]) PrevExp() Node[K, V]

func (*BSE[K, V]) RefreshableAt 

func (n *BSE[K, V]) RefreshableAt() int64

func (*BSE[K, V]) Retire 

func (n *BSE[K, V]) Retire()

func (*BSE[K, V]) SetExpiresAt 

func (n *BSE[K, V]) SetExpiresAt(new int64)

func (*BSE[K, V]) SetNext 

func (n *BSE[K, V]) SetNext(v Node[K, V])

func (*BSE[K, V]) SetNextExp 

func (n *BSE[K, V]) SetNextExp(v Node[K, V])

func (*BSE[K, V]) SetPrev 

func (n *BSE[K, V]) SetPrev(v Node[K, V])

func (*BSE[K, V]) SetPrevExp 

func (n *BSE[K, V]) SetPrevExp(v Node[K, V])

func (*BSE[K, V]) SetQueueType 

func (n *BSE[K, V]) SetQueueType(queueType uint8)

func (*BSE[K, V]) SetRefreshableAt 

func (n *BSE[K, V]) SetRefreshableAt(new int64)

func (*BSE[K, V]) Value 

func (n *BSE[K, V]) Value() V

func (*BSE[K, V]) Weight 

func (n *BSE[K, V]) Weight() uint32

type BSER 

type BSER[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BSER is a cache entry that provide the following features:

1. Base

2. Size

3. Expiration

4. Refresh

func (*BSER[K, V]) AsPointer 

func (n *BSER[K, V]) AsPointer() unsafe.Pointer

func (*BSER[K, V]) CASExpiresAt 

func (n *BSER[K, V]) CASExpiresAt(old, new int64) bool

func (*BSER[K, V]) CASRefreshableAt 

func (n *BSER[K, V]) CASRefreshableAt(old, new int64) bool

func (*BSER[K, V]) Die 

func (n *BSER[K, V]) Die()

func (*BSER[K, V]) ExpiresAt 

func (n *BSER[K, V]) ExpiresAt() int64

func (*BSER[K, V]) GetQueueType 

func (n *BSER[K, V]) GetQueueType() uint8

func (*BSER[K, V]) HasExpired 

func (n *BSER[K, V]) HasExpired(now int64) bool

func (*BSER[K, V]) InMainProbation 

func (n *BSER[K, V]) InMainProbation() bool

func (*BSER[K, V]) InMainProtected 

func (n *BSER[K, V]) InMainProtected() bool

func (*BSER[K, V]) InWindow 

func (n *BSER[K, V]) InWindow() bool

func (*BSER[K, V]) IsAlive 

func (n *BSER[K, V]) IsAlive() bool

func (*BSER[K, V]) IsDead 

func (n *BSER[K, V]) IsDead() bool

func (*BSER[K, V]) IsFresh 

func (n *BSER[K, V]) IsFresh(now int64) bool

func (*BSER[K, V]) IsRetired 

func (n *BSER[K, V]) IsRetired() bool

func (*BSER[K, V]) Key 

func (n *BSER[K, V]) Key() K

func (*BSER[K, V]) MakeMainProbation 

func (n *BSER[K, V]) MakeMainProbation()

func (*BSER[K, V]) MakeMainProtected 

func (n *BSER[K, V]) MakeMainProtected()

func (*BSER[K, V]) MakeWindow 

func (n *BSER[K, V]) MakeWindow()

func (*BSER[K, V]) Next 

func (n *BSER[K, V]) Next() Node[K, V]

func (*BSER[K, V]) NextExp 

func (n *BSER[K, V]) NextExp() Node[K, V]

func (*BSER[K, V]) Prev 

func (n *BSER[K, V]) Prev() Node[K, V]

func (*BSER[K, V]) PrevExp 

func (n *BSER[K, V]) PrevExp() Node[K, V]

func (*BSER[K, V]) RefreshableAt 

func (n *BSER[K, V]) RefreshableAt() int64

func (*BSER[K, V]) Retire 

func (n *BSER[K, V]) Retire()

func (*BSER[K, V]) SetExpiresAt 

func (n *BSER[K, V]) SetExpiresAt(new int64)

func (*BSER[K, V]) SetNext 

func (n *BSER[K, V]) SetNext(v Node[K, V])

func (*BSER[K, V]) SetNextExp 

func (n *BSER[K, V]) SetNextExp(v Node[K, V])

func (*BSER[K, V]) SetPrev 

func (n *BSER[K, V]) SetPrev(v Node[K, V])

func (*BSER[K, V]) SetPrevExp 

func (n *BSER[K, V]) SetPrevExp(v Node[K, V])

func (*BSER[K, V]) SetQueueType 

func (n *BSER[K, V]) SetQueueType(queueType uint8)

func (*BSER[K, V]) SetRefreshableAt 

func (n *BSER[K, V]) SetRefreshableAt(new int64)

func (*BSER[K, V]) Value 

func (n *BSER[K, V]) Value() V

func (*BSER[K, V]) Weight 

func (n *BSER[K, V]) Weight() uint32

type BSR 

type BSR[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BSR is a cache entry that provide the following features:

1. Base

2. Size

3. Refresh

func (*BSR[K, V]) AsPointer 

func (n *BSR[K, V]) AsPointer() unsafe.Pointer

func (*BSR[K, V]) CASExpiresAt 

func (n *BSR[K, V]) CASExpiresAt(old, new int64) bool

func (*BSR[K, V]) CASRefreshableAt 

func (n *BSR[K, V]) CASRefreshableAt(old, new int64) bool

func (*BSR[K, V]) Die 

func (n *BSR[K, V]) Die()

func (*BSR[K, V]) ExpiresAt 

func (n *BSR[K, V]) ExpiresAt() int64

func (*BSR[K, V]) GetQueueType 

func (n *BSR[K, V]) GetQueueType() uint8

func (*BSR[K, V]) HasExpired 

func (n *BSR[K, V]) HasExpired(now int64) bool

func (*BSR[K, V]) InMainProbation 

func (n *BSR[K, V]) InMainProbation() bool

func (*BSR[K, V]) InMainProtected 

func (n *BSR[K, V]) InMainProtected() bool

func (*BSR[K, V]) InWindow 

func (n *BSR[K, V]) InWindow() bool

func (*BSR[K, V]) IsAlive 

func (n *BSR[K, V]) IsAlive() bool

func (*BSR[K, V]) IsDead 

func (n *BSR[K, V]) IsDead() bool

func (*BSR[K, V]) IsFresh 

func (n *BSR[K, V]) IsFresh(now int64) bool

func (*BSR[K, V]) IsRetired 

func (n *BSR[K, V]) IsRetired() bool

func (*BSR[K, V]) Key 

func (n *BSR[K, V]) Key() K

func (*BSR[K, V]) MakeMainProbation 

func (n *BSR[K, V]) MakeMainProbation()

func (*BSR[K, V]) MakeMainProtected 

func (n *BSR[K, V]) MakeMainProtected()

func (*BSR[K, V]) MakeWindow 

func (n *BSR[K, V]) MakeWindow()

func (*BSR[K, V]) Next 

func (n *BSR[K, V]) Next() Node[K, V]

func (*BSR[K, V]) NextExp 

func (n *BSR[K, V]) NextExp() Node[K, V]

func (*BSR[K, V]) Prev 

func (n *BSR[K, V]) Prev() Node[K, V]

func (*BSR[K, V]) PrevExp 

func (n *BSR[K, V]) PrevExp() Node[K, V]

func (*BSR[K, V]) RefreshableAt 

func (n *BSR[K, V]) RefreshableAt() int64

func (*BSR[K, V]) Retire 

func (n *BSR[K, V]) Retire()

func (*BSR[K, V]) SetExpiresAt 

func (n *BSR[K, V]) SetExpiresAt(new int64)

func (*BSR[K, V]) SetNext 

func (n *BSR[K, V]) SetNext(v Node[K, V])

func (*BSR[K, V]) SetNextExp 

func (n *BSR[K, V]) SetNextExp(v Node[K, V])

func (*BSR[K, V]) SetPrev 

func (n *BSR[K, V]) SetPrev(v Node[K, V])

func (*BSR[K, V]) SetPrevExp 

func (n *BSR[K, V]) SetPrevExp(v Node[K, V])

func (*BSR[K, V]) SetQueueType 

func (n *BSR[K, V]) SetQueueType(queueType uint8)

func (*BSR[K, V]) SetRefreshableAt 

func (n *BSR[K, V]) SetRefreshableAt(new int64)

func (*BSR[K, V]) Value 

func (n *BSR[K, V]) Value() V

func (*BSR[K, V]) Weight 

func (n *BSR[K, V]) Weight() uint32

type BW 

type BW[K comparable, V any] struct {
	// contains filtered or unexported fields
}

BW is a cache entry that provide the following features:

1. Base

2. Weight

func (*BW[K, V]) AsPointer 

func (n *BW[K, V]) AsPointer() unsafe.Pointer

func (*BW[K, V]) CASExpiresAt 

func (n *BW[K, V]) CASExpiresAt(old, new int64) bool

func (*BW[K, V]) CASRefreshableAt 

func (n *BW[K, V]) CASRefreshableAt(old, new int64) bool

func (*BW[K, V]) Die 

func (n *BW[K, V]) Die()

func (*BW[K, V]) ExpiresAt 

func (n *BW[K, V]) ExpiresAt() int64

func (*BW[K, V]) GetQueueType 

func (n *BW[K, V]) GetQueueType() uint8

func (*BW[K, V]) HasExpired 

func (n *BW[K, V]) HasExpired(now int64) bool

func (*BW[K, V]) InMainProbation 

func (n *BW[K, V]) InMainProbation() bool

func (*BW[K, V]) InMainProtected 

func (n *BW[K, V]) InMainProtected() bool

func (*BW[K, V]) InWindow 

func (n *BW[K, V]) InWindow() bool

func (*BW[K, V]) IsAlive 

func (n *BW[K, V]) IsAlive() bool

func (*BW[K, V]) IsDead 

func (n *BW[K, V]) IsDead() bool

func (*BW[K, V]) IsFresh 

func (n *BW[K, V]) IsFresh(now int64) bool

func (*BW[K, V]) IsRetired 

func (n *BW[K, V]) IsRetired() bool

func (*BW[K, V]) Key 

func (n *BW[K, V]) Key() K

func (*BW[K, V]) MakeMainProbation 

func (n *BW[K, V]) MakeMainProbation()

func (*BW[K, V]) MakeMainProtected 

func (n *BW[K, V]) MakeMainProtected()

func (*BW[K, V]) MakeWindow 

func (n *BW[K, V]) MakeWindow()

func (*BW[K, V]) Next 

func (n *BW[K, V]) Next() Node[K, V]

func (*BW[K, V]) NextExp 

func (n *BW[K, V]) NextExp() Node[K, V]

func (*BW[K, V]) Prev 

func (n *BW[K, V]) Prev() Node[K, V]

func (*BW[K, V]) PrevExp 

func (n *BW[K, V]) PrevExp() Node[K, V]

func (*BW[K, V]) RefreshableAt 

func (n *BW[K, V]) RefreshableAt() int64

func (*BW[K, V]) Retire 

func (n *BW[K, V]) Retire()

func (*BW[K, V]) SetExpiresAt 

func (n *BW[K, V]) SetExpiresAt(new int64)

func (*BW[K, V]) SetNext 

func (n *BW[K, V]) SetNext(v Node[K, V])

func (*BW[K, V]) SetNextExp 

func (n *BW[K, V]) SetNextExp(v Node[K, V])

func (*BW[K, V]) SetPrev 

func (n *BW[K, V]) SetPrev(v Node[K, V])

func (*BW[K, V]) SetPrevExp 

func (n *BW[K, V]) SetPrevExp(v Node[K, V])

func (*BW[K, V]) SetQueueType 

func (n *BW[K, V]) SetQueueType(queueType uint8)

func (*BW[K, V]) SetRefreshableAt 

func (n *BW[K, V]) SetRefreshableAt(new int64)

func (*BW[K, V]) Value 

func (n *BW[K, V]) Value() V

func (*BW[K, V]) Weight 

func (n *BW[K, V]) Weight() uint32

type Config 

type Config struct {
	WithSize       bool
	WithExpiration bool
	WithWeight     bool
	WithRefresh    bool
}

type Manager 

type Manager[K comparable, V any] struct {
	// contains filtered or unexported fields
}

func NewManager 

func NewManager[K comparable, V any](c Config) *Manager[K, V]

func (*Manager[K, V]) Create 

func (m *Manager[K, V]) Create(key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

func (*Manager[K, V]) FromPointer 

func (m *Manager[K, V]) FromPointer(ptr unsafe.Pointer) Node[K, V]

func (*Manager[K, V]) IsNil 

func (m *Manager[K, V]) IsNil(n Node[K, V]) bool

type Node 

type Node[K comparable, V any] interface {
	// Key returns the key.
	Key() K
	// Value returns the value.
	Value() V
	// AsPointer returns the node as a pointer.
	AsPointer() unsafe.Pointer
	// Prev returns the previous node in the eviction policy.
	Prev() Node[K, V]
	// SetPrev sets the previous node in the eviction policy.
	SetPrev(v Node[K, V])
	// Next returns the next node in the eviction policy.
	Next() Node[K, V]
	// SetNext sets the next node in the eviction policy.
	SetNext(v Node[K, V])
	// PrevExp returns the previous node in the expiration policy.
	PrevExp() Node[K, V]
	// SetPrevExp sets the previous node in the expiration policy.
	SetPrevExp(v Node[K, V])
	// NextExp returns the next node in the expiration policy.
	NextExp() Node[K, V]
	// SetNextExp sets the next node in the expiration policy.
	SetNextExp(v Node[K, V])
	// HasExpired returns true if node has expired.
	HasExpired(now int64) bool
	// ExpiresAt returns the expiration time.
	ExpiresAt() int64
	// CASExpiresAt executes the compare-and-swap operation for expiresAt.
	CASExpiresAt(old, new int64) bool
	// SetExpiresAt sets the expiration time.
	SetExpiresAt(new int64)
	// RefreshableAt returns the refresh time.
	RefreshableAt() int64
	// CASRefreshableAt executes the compare-and-swap operation for refreshableAt.
	CASRefreshableAt(old, new int64) bool
	// SetRefreshableAt returns the refresh time.
	SetRefreshableAt(new int64)
	IsFresh(now int64) bool
	// Weight returns the weight of the node.
	Weight() uint32
	// IsAlive returns true if the entry is available in the hash-table and page replacement policy.
	IsAlive() bool
	// IsRetired returns true if the entry was removed from the hash-table and is awaiting removal from the page
	// replacement policy.
	IsRetired() bool
	// Retire sets the node to the retired state.
	Retire()
	// IsDead returns true if the entry was removed from the hash-table and the page replacement policy.
	IsDead() bool
	// Die sets the node to the dead state.
	Die()
	// GetQueueType returns the queue that the entry's resides in (window, probation, or protected).
	GetQueueType() uint8
	// SetQueueType sets queue that the entry resides in (window, probation, or protected).
	SetQueueType(queueType uint8)
	// InWindow returns true if the entry is in the Window or Main space.
	InWindow() bool
	// MakeWindow sets the status to the Window queue.
	MakeWindow()
	// InMainProbation returns true if the entry is in the Main space's probation queue.
	InMainProbation() bool
	// MakeMainProbation sets the status to the Main space's probation queue.
	MakeMainProbation()
	// InMainProtected returns if the entry is in the Main space's protected queue.
	InMainProtected() bool
	// MakeMainProtected sets the status to the Main space's protected queue.
	MakeMainProtected()
}

Node is a cache entry.

func CastPointerToB 

func CastPointerToB[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToB casts a pointer to B.

func CastPointerToBE 

func CastPointerToBE[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBE casts a pointer to BE.

func CastPointerToBER 

func CastPointerToBER[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBER casts a pointer to BER.

func CastPointerToBERW 

func CastPointerToBERW[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBERW casts a pointer to BERW.

func CastPointerToBEW 

func CastPointerToBEW[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBEW casts a pointer to BEW.

func CastPointerToBR 

func CastPointerToBR[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBR casts a pointer to BR.

func CastPointerToBRW 

func CastPointerToBRW[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBRW casts a pointer to BRW.

func CastPointerToBS 

func CastPointerToBS[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBS casts a pointer to BS.

func CastPointerToBSE 

func CastPointerToBSE[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBSE casts a pointer to BSE.

func CastPointerToBSER 

func CastPointerToBSER[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBSER casts a pointer to BSER.

func CastPointerToBSR 

func CastPointerToBSR[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBSR casts a pointer to BSR.

func CastPointerToBW 

func CastPointerToBW[K comparable, V any](ptr unsafe.Pointer) Node[K, V]

CastPointerToBW casts a pointer to BW.

func NewB 

func NewB[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewB creates a new B.

func NewBE 

func NewBE[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBE creates a new BE.

func NewBER 

func NewBER[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBER creates a new BER.

func NewBERW 

func NewBERW[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBERW creates a new BERW.

func NewBEW 

func NewBEW[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBEW creates a new BEW.

func NewBR 

func NewBR[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBR creates a new BR.

func NewBRW 

func NewBRW[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBRW creates a new BRW.

func NewBS 

func NewBS[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBS creates a new BS.

func NewBSE 

func NewBSE[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBSE creates a new BSE.

func NewBSER 

func NewBSER[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBSER creates a new BSER.

func NewBSR 

func NewBSR[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBSR creates a new BSR.

func NewBW 

func NewBW[K comparable, V any](key K, value V, expiresAt, refreshableAt int64, weight uint32) Node[K, V]

NewBW creates a new BW.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.