kit

package module
v0.9.2 Latest Latest
Warning

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

Go to latest
Published: Oct 4, 2025 License: Unlicense Imports: 9 Imported by: 4

README

WIP

Documentation

Index

Constants

This section is empty.

Variables

View Source
var (
	ErrLogUnsupported = errors.New("matt::kit::log: unsupported")
	ErrLogCorruption  = errors.New("matt::kit::log: corruption")
	ErrLogObsolete    = errors.New("matt::kit::log: obsolete")
	ErrLogNoData      = errors.New("matt::kit::log: no data")
)
View Source
var (
	ErrSetNotFound = errors.New("matt::kit::set: not found")
	ErrSetFull     = errors.New("matt::kit::set: full")
)
View Source
var ErrMapNotFound = errors.New("matt::kit::map: not found")
View Source
var ErrRegistryNotFound = errors.New("matt::kit::registry: not found")

Functions

func BoolToInt

func BoolToInt(true bool) int

func Close

func Close[T any](ch chan<- T)

func InitBiboFreelist10

func InitBiboFreelist10[T any](freelist *BiboFreelist10[T], factory func(uint) T)

func InitBiboFreelist11

func InitBiboFreelist11[T any](freelist *BiboFreelist11[T], factory func(uint) T)

func InitBiboFreelist12

func InitBiboFreelist12[T any](freelist *BiboFreelist12[T], factory func(uint) T)

func InitBiboFreelist13

func InitBiboFreelist13[T any](freelist *BiboFreelist13[T], factory func(uint) T)

func InitBiboFreelist14

func InitBiboFreelist14[T any](freelist *BiboFreelist14[T], factory func(uint) T)

func InitBiboFreelist15

func InitBiboFreelist15[T any](freelist *BiboFreelist15[T], factory func(uint) T)

func InitBiboFreelist16

func InitBiboFreelist16[T any](freelist *BiboFreelist16[T], factory func(uint) T)

func InitBiboFreelist17

func InitBiboFreelist17[T any](freelist *BiboFreelist17[T], factory func(uint) T)

func InitBiboFreelist18

func InitBiboFreelist18[T any](freelist *BiboFreelist18[T], factory func(uint) T)

func InitBiboFreelist19

func InitBiboFreelist19[T any](freelist *BiboFreelist19[T], factory func(uint) T)

func InitBiboFreelist20

func InitBiboFreelist20[T any](freelist *BiboFreelist20[T], factory func(uint) T)

func InitBiboFreelist21

func InitBiboFreelist21[T any](freelist *BiboFreelist21[T], factory func(uint) T)

func InitBiboFreelist22

func InitBiboFreelist22[T any](freelist *BiboFreelist22[T], factory func(uint) T)

func InitBiboFreelist23

func InitBiboFreelist23[T any](freelist *BiboFreelist23[T], factory func(uint) T)

func InitBiboFreelist24

func InitBiboFreelist24[T any](freelist *BiboFreelist24[T], factory func(uint) T)

func InitBiboFreelist25

func InitBiboFreelist25[T any](freelist *BiboFreelist25[T], factory func(uint) T)

func InitBiboFreelist26

func InitBiboFreelist26[T any](freelist *BiboFreelist26[T], factory func(uint) T)

func InitBiboFreelist27

func InitBiboFreelist27[T any](freelist *BiboFreelist27[T], factory func(uint) T)

func InitBiboFreelist28

func InitBiboFreelist28[T any](freelist *BiboFreelist28[T], factory func(uint) T)

func InitBiboFreelist29

func InitBiboFreelist29[T any](freelist *BiboFreelist29[T], factory func(uint) T)

func InitBiboFreelist30

func InitBiboFreelist30[T any](freelist *BiboFreelist30[T], factory func(uint) T)

func InitBiboFreelist31

func InitBiboFreelist31[T any](freelist *BiboFreelist31[T], factory func(uint) T)

func InitBiboFreelist32

func InitBiboFreelist32[T any](freelist *BiboFreelist32[T], factory func(uint) T)

func InitBiboFreelist33

func InitBiboFreelist33[T any](freelist *BiboFreelist33[T], factory func(uint) T)

func InitBiboFreelist34

func InitBiboFreelist34[T any](freelist *BiboFreelist34[T], factory func(uint) T)

func InitBiboFreelist7

func InitBiboFreelist7[T any](freelist *BiboFreelist7[T], factory func(uint) T)

func InitBiboFreelist8

func InitBiboFreelist8[T any](freelist *BiboFreelist8[T], factory func(uint) T)

func InitBiboFreelist9

func InitBiboFreelist9[T any](freelist *BiboFreelist9[T], factory func(uint) T)

func InitCoarseMap

func InitCoarseMap[K comparable, V any](m *CoarseMap[K, V], capacity int)

func InitCoarseRegistry

func InitCoarseRegistry[K comparable, V any](registry *CoarseRegistry[K, V], capacity int)

func InitFifoFreelist0

func InitFifoFreelist0[T any](freelist *FifoFreelist0[T], factory func(uint) T)

func InitFifoFreelist1

func InitFifoFreelist1[T any](freelist *FifoFreelist1[T], factory func(uint) T)

func InitFifoFreelist10

func InitFifoFreelist10[T any](freelist *FifoFreelist10[T], factory func(uint) T)

func InitFifoFreelist11

func InitFifoFreelist11[T any](freelist *FifoFreelist11[T], factory func(uint) T)

func InitFifoFreelist12

func InitFifoFreelist12[T any](freelist *FifoFreelist12[T], factory func(uint) T)

func InitFifoFreelist13

func InitFifoFreelist13[T any](freelist *FifoFreelist13[T], factory func(uint) T)

func InitFifoFreelist14

func InitFifoFreelist14[T any](freelist *FifoFreelist14[T], factory func(uint) T)

func InitFifoFreelist15

func InitFifoFreelist15[T any](freelist *FifoFreelist15[T], factory func(uint) T)

func InitFifoFreelist16

func InitFifoFreelist16[T any](freelist *FifoFreelist16[T], factory func(uint) T)

func InitFifoFreelist17

func InitFifoFreelist17[T any](freelist *FifoFreelist17[T], factory func(uint) T)

func InitFifoFreelist18

func InitFifoFreelist18[T any](freelist *FifoFreelist18[T], factory func(uint) T)

func InitFifoFreelist19

func InitFifoFreelist19[T any](freelist *FifoFreelist19[T], factory func(uint) T)

func InitFifoFreelist2

func InitFifoFreelist2[T any](freelist *FifoFreelist2[T], factory func(uint) T)

func InitFifoFreelist20

func InitFifoFreelist20[T any](freelist *FifoFreelist20[T], factory func(uint) T)

func InitFifoFreelist21

func InitFifoFreelist21[T any](freelist *FifoFreelist21[T], factory func(uint) T)

func InitFifoFreelist22

func InitFifoFreelist22[T any](freelist *FifoFreelist22[T], factory func(uint) T)

func InitFifoFreelist23

func InitFifoFreelist23[T any](freelist *FifoFreelist23[T], factory func(uint) T)

func InitFifoFreelist24

func InitFifoFreelist24[T any](freelist *FifoFreelist24[T], factory func(uint) T)

func InitFifoFreelist25

func InitFifoFreelist25[T any](freelist *FifoFreelist25[T], factory func(uint) T)

func InitFifoFreelist26

func InitFifoFreelist26[T any](freelist *FifoFreelist26[T], factory func(uint) T)

func InitFifoFreelist27

func InitFifoFreelist27[T any](freelist *FifoFreelist27[T], factory func(uint) T)

func InitFifoFreelist28

func InitFifoFreelist28[T any](freelist *FifoFreelist28[T], factory func(uint) T)

func InitFifoFreelist29

func InitFifoFreelist29[T any](freelist *FifoFreelist29[T], factory func(uint) T)

func InitFifoFreelist3

func InitFifoFreelist3[T any](freelist *FifoFreelist3[T], factory func(uint) T)

func InitFifoFreelist30

func InitFifoFreelist30[T any](freelist *FifoFreelist30[T], factory func(uint) T)

func InitFifoFreelist31

func InitFifoFreelist31[T any](freelist *FifoFreelist31[T], factory func(uint) T)

func InitFifoFreelist32

func InitFifoFreelist32[T any](freelist *FifoFreelist32[T], factory func(uint) T)

func InitFifoFreelist33

func InitFifoFreelist33[T any](freelist *FifoFreelist33[T], factory func(uint) T)

func InitFifoFreelist34

func InitFifoFreelist34[T any](freelist *FifoFreelist34[T], factory func(uint) T)

func InitFifoFreelist4

func InitFifoFreelist4[T any](freelist *FifoFreelist4[T], factory func(uint) T)

func InitFifoFreelist5

func InitFifoFreelist5[T any](freelist *FifoFreelist5[T], factory func(uint) T)

func InitFifoFreelist6

func InitFifoFreelist6[T any](freelist *FifoFreelist6[T], factory func(uint) T)

func InitFifoFreelist7

func InitFifoFreelist7[T any](freelist *FifoFreelist7[T], factory func(uint) T)

func InitFifoFreelist8

func InitFifoFreelist8[T any](freelist *FifoFreelist8[T], factory func(uint) T)

func InitFifoFreelist9

func InitFifoFreelist9[T any](freelist *FifoFreelist9[T], factory func(uint) T)

func InitLifoFreelist0

func InitLifoFreelist0[T any](freelist *LifoFreelist0[T], factory func(uint) T)

func InitLifoFreelist1

func InitLifoFreelist1[T any](freelist *LifoFreelist1[T], factory func(uint) T)

func InitLifoFreelist10

func InitLifoFreelist10[T any](freelist *LifoFreelist10[T], factory func(uint) T)

func InitLifoFreelist11

func InitLifoFreelist11[T any](freelist *LifoFreelist11[T], factory func(uint) T)

func InitLifoFreelist12

func InitLifoFreelist12[T any](freelist *LifoFreelist12[T], factory func(uint) T)

func InitLifoFreelist13

func InitLifoFreelist13[T any](freelist *LifoFreelist13[T], factory func(uint) T)

func InitLifoFreelist14

func InitLifoFreelist14[T any](freelist *LifoFreelist14[T], factory func(uint) T)

func InitLifoFreelist15

func InitLifoFreelist15[T any](freelist *LifoFreelist15[T], factory func(uint) T)

func InitLifoFreelist16

func InitLifoFreelist16[T any](freelist *LifoFreelist16[T], factory func(uint) T)

func InitLifoFreelist17

func InitLifoFreelist17[T any](freelist *LifoFreelist17[T], factory func(uint) T)

func InitLifoFreelist18

func InitLifoFreelist18[T any](freelist *LifoFreelist18[T], factory func(uint) T)

func InitLifoFreelist19

func InitLifoFreelist19[T any](freelist *LifoFreelist19[T], factory func(uint) T)

func InitLifoFreelist2

func InitLifoFreelist2[T any](freelist *LifoFreelist2[T], factory func(uint) T)

func InitLifoFreelist20

func InitLifoFreelist20[T any](freelist *LifoFreelist20[T], factory func(uint) T)

func InitLifoFreelist21

func InitLifoFreelist21[T any](freelist *LifoFreelist21[T], factory func(uint) T)

func InitLifoFreelist22

func InitLifoFreelist22[T any](freelist *LifoFreelist22[T], factory func(uint) T)

func InitLifoFreelist23

func InitLifoFreelist23[T any](freelist *LifoFreelist23[T], factory func(uint) T)

func InitLifoFreelist24

func InitLifoFreelist24[T any](freelist *LifoFreelist24[T], factory func(uint) T)

func InitLifoFreelist25

func InitLifoFreelist25[T any](freelist *LifoFreelist25[T], factory func(uint) T)

func InitLifoFreelist26

func InitLifoFreelist26[T any](freelist *LifoFreelist26[T], factory func(uint) T)

func InitLifoFreelist27

func InitLifoFreelist27[T any](freelist *LifoFreelist27[T], factory func(uint) T)

func InitLifoFreelist28

func InitLifoFreelist28[T any](freelist *LifoFreelist28[T], factory func(uint) T)

func InitLifoFreelist29

func InitLifoFreelist29[T any](freelist *LifoFreelist29[T], factory func(uint) T)

func InitLifoFreelist3

func InitLifoFreelist3[T any](freelist *LifoFreelist3[T], factory func(uint) T)

func InitLifoFreelist30

func InitLifoFreelist30[T any](freelist *LifoFreelist30[T], factory func(uint) T)

func InitLifoFreelist31

func InitLifoFreelist31[T any](freelist *LifoFreelist31[T], factory func(uint) T)

func InitLifoFreelist32

func InitLifoFreelist32[T any](freelist *LifoFreelist32[T], factory func(uint) T)

func InitLifoFreelist33

func InitLifoFreelist33[T any](freelist *LifoFreelist33[T], factory func(uint) T)

func InitLifoFreelist34

func InitLifoFreelist34[T any](freelist *LifoFreelist34[T], factory func(uint) T)

func InitLifoFreelist4

func InitLifoFreelist4[T any](freelist *LifoFreelist4[T], factory func(uint) T)

func InitLifoFreelist5

func InitLifoFreelist5[T any](freelist *LifoFreelist5[T], factory func(uint) T)

func InitLifoFreelist6

func InitLifoFreelist6[T any](freelist *LifoFreelist6[T], factory func(uint) T)

func InitLifoFreelist7

func InitLifoFreelist7[T any](freelist *LifoFreelist7[T], factory func(uint) T)

func InitLifoFreelist8

func InitLifoFreelist8[T any](freelist *LifoFreelist8[T], factory func(uint) T)

func InitLifoFreelist9

func InitLifoFreelist9[T any](freelist *LifoFreelist9[T], factory func(uint) T)

func InitLowfiFreelist0

func InitLowfiFreelist0[T any](freelist *LowfiFreelist0[T], factory func(uint) T)

func InitLowfiFreelist1

func InitLowfiFreelist1[T any](freelist *LowfiFreelist1[T], factory func(uint) T)

func InitLowfiFreelist10

func InitLowfiFreelist10[T any](freelist *LowfiFreelist10[T], factory func(uint) T)

func InitLowfiFreelist11

func InitLowfiFreelist11[T any](freelist *LowfiFreelist11[T], factory func(uint) T)

func InitLowfiFreelist12

func InitLowfiFreelist12[T any](freelist *LowfiFreelist12[T], factory func(uint) T)

func InitLowfiFreelist13

func InitLowfiFreelist13[T any](freelist *LowfiFreelist13[T], factory func(uint) T)

func InitLowfiFreelist14

func InitLowfiFreelist14[T any](freelist *LowfiFreelist14[T], factory func(uint) T)

func InitLowfiFreelist15

func InitLowfiFreelist15[T any](freelist *LowfiFreelist15[T], factory func(uint) T)

func InitLowfiFreelist16

func InitLowfiFreelist16[T any](freelist *LowfiFreelist16[T], factory func(uint) T)

func InitLowfiFreelist17

func InitLowfiFreelist17[T any](freelist *LowfiFreelist17[T], factory func(uint) T)

func InitLowfiFreelist18

func InitLowfiFreelist18[T any](freelist *LowfiFreelist18[T], factory func(uint) T)

func InitLowfiFreelist19

func InitLowfiFreelist19[T any](freelist *LowfiFreelist19[T], factory func(uint) T)

func InitLowfiFreelist2

func InitLowfiFreelist2[T any](freelist *LowfiFreelist2[T], factory func(uint) T)

func InitLowfiFreelist20

func InitLowfiFreelist20[T any](freelist *LowfiFreelist20[T], factory func(uint) T)

func InitLowfiFreelist21

func InitLowfiFreelist21[T any](freelist *LowfiFreelist21[T], factory func(uint) T)

func InitLowfiFreelist22

func InitLowfiFreelist22[T any](freelist *LowfiFreelist22[T], factory func(uint) T)

func InitLowfiFreelist23

func InitLowfiFreelist23[T any](freelist *LowfiFreelist23[T], factory func(uint) T)

func InitLowfiFreelist24

func InitLowfiFreelist24[T any](freelist *LowfiFreelist24[T], factory func(uint) T)

func InitLowfiFreelist25

func InitLowfiFreelist25[T any](freelist *LowfiFreelist25[T], factory func(uint) T)

func InitLowfiFreelist26

func InitLowfiFreelist26[T any](freelist *LowfiFreelist26[T], factory func(uint) T)

func InitLowfiFreelist27

func InitLowfiFreelist27[T any](freelist *LowfiFreelist27[T], factory func(uint) T)

func InitLowfiFreelist28

func InitLowfiFreelist28[T any](freelist *LowfiFreelist28[T], factory func(uint) T)

func InitLowfiFreelist29

func InitLowfiFreelist29[T any](freelist *LowfiFreelist29[T], factory func(uint) T)

func InitLowfiFreelist3

func InitLowfiFreelist3[T any](freelist *LowfiFreelist3[T], factory func(uint) T)

func InitLowfiFreelist30

func InitLowfiFreelist30[T any](freelist *LowfiFreelist30[T], factory func(uint) T)

func InitLowfiFreelist31

func InitLowfiFreelist31[T any](freelist *LowfiFreelist31[T], factory func(uint) T)

func InitLowfiFreelist32

func InitLowfiFreelist32[T any](freelist *LowfiFreelist32[T], factory func(uint) T)

func InitLowfiFreelist33

func InitLowfiFreelist33[T any](freelist *LowfiFreelist33[T], factory func(uint) T)

func InitLowfiFreelist34

func InitLowfiFreelist34[T any](freelist *LowfiFreelist34[T], factory func(uint) T)

func InitLowfiFreelist4

func InitLowfiFreelist4[T any](freelist *LowfiFreelist4[T], factory func(uint) T)

func InitLowfiFreelist5

func InitLowfiFreelist5[T any](freelist *LowfiFreelist5[T], factory func(uint) T)

func InitLowfiFreelist6

func InitLowfiFreelist6[T any](freelist *LowfiFreelist6[T], factory func(uint) T)

func InitLowfiFreelist7

func InitLowfiFreelist7[T any](freelist *LowfiFreelist7[T], factory func(uint) T)

func InitLowfiFreelist8

func InitLowfiFreelist8[T any](freelist *LowfiFreelist8[T], factory func(uint) T)

func InitLowfiFreelist9

func InitLowfiFreelist9[T any](freelist *LowfiFreelist9[T], factory func(uint) T)

func NewBiboAs

func NewBiboAs() bool

func NewFifoAs

func NewFifoAs() bool

func NewHeapAs

func NewHeapAs() bool

func NewHeapLowBitSet

func NewHeapLowBitSet[T common.Standard[T, uint]](lowBitsUsed uint) common.Queue[T]

func NewLifoAs

func NewLifoAs() bool

func NewLog

func NewLog[T common.UnixTimestamped](stepWindow, retention time.Duration, capPerLinkedNode int) common.Log[T]

TODO: element timestamps must be > than logWindow; bucket's element caps must remain constant

func NewLogAs

func NewLogAs() bool

func NewLowfiAs

func NewLowfiAs() bool

func NewMapAs

func NewMapAs() bool

func NewRegistryAs

func NewRegistryAs() bool

func NewRingAs

func NewRingAs() bool

func NewSetAs

func NewSetAs() bool

func Pack16

func Pack16(low, high uint64) (array [help.SixteenInt]byte)

func UnixNano

func UnixNano() int64

func Unpack16

func Unpack16(array [help.SixteenInt]byte) (low, high uint64)

Types

type BiboFreelist10

type BiboFreelist10[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist10

func NewBiboFreelist10[T any](factory func(uint) T) *BiboFreelist10[T]

func (*BiboFreelist10[T]) Cap

func (this *BiboFreelist10[T]) Cap() int

func (*BiboFreelist10[T]) Get

func (this *BiboFreelist10[T]) Get() (*T, bool)

func (*BiboFreelist10[T]) Len

func (this *BiboFreelist10[T]) Len() int

func (*BiboFreelist10[T]) Release

func (this *BiboFreelist10[T]) Release(id uint) bool

type BiboFreelist11

type BiboFreelist11[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist11

func NewBiboFreelist11[T any](factory func(uint) T) *BiboFreelist11[T]

func (*BiboFreelist11[T]) Cap

func (this *BiboFreelist11[T]) Cap() int

func (*BiboFreelist11[T]) Get

func (this *BiboFreelist11[T]) Get() (*T, bool)

func (*BiboFreelist11[T]) Len

func (this *BiboFreelist11[T]) Len() int

func (*BiboFreelist11[T]) Release

func (this *BiboFreelist11[T]) Release(id uint) bool

type BiboFreelist12

type BiboFreelist12[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist12

func NewBiboFreelist12[T any](factory func(uint) T) *BiboFreelist12[T]

func (*BiboFreelist12[T]) Cap

func (this *BiboFreelist12[T]) Cap() int

func (*BiboFreelist12[T]) Get

func (this *BiboFreelist12[T]) Get() (*T, bool)

func (*BiboFreelist12[T]) Len

func (this *BiboFreelist12[T]) Len() int

func (*BiboFreelist12[T]) Release

func (this *BiboFreelist12[T]) Release(id uint) bool

type BiboFreelist13

type BiboFreelist13[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist13

func NewBiboFreelist13[T any](factory func(uint) T) *BiboFreelist13[T]

func (*BiboFreelist13[T]) Cap

func (this *BiboFreelist13[T]) Cap() int

func (*BiboFreelist13[T]) Get

func (this *BiboFreelist13[T]) Get() (*T, bool)

func (*BiboFreelist13[T]) Len

func (this *BiboFreelist13[T]) Len() int

func (*BiboFreelist13[T]) Release

func (this *BiboFreelist13[T]) Release(id uint) bool

type BiboFreelist14

type BiboFreelist14[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist14

func NewBiboFreelist14[T any](factory func(uint) T) *BiboFreelist14[T]

func (*BiboFreelist14[T]) Cap

func (this *BiboFreelist14[T]) Cap() int

func (*BiboFreelist14[T]) Get

func (this *BiboFreelist14[T]) Get() (*T, bool)

func (*BiboFreelist14[T]) Len

func (this *BiboFreelist14[T]) Len() int

func (*BiboFreelist14[T]) Release

func (this *BiboFreelist14[T]) Release(id uint) bool

type BiboFreelist15

type BiboFreelist15[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist15

func NewBiboFreelist15[T any](factory func(uint) T) *BiboFreelist15[T]

func (*BiboFreelist15[T]) Cap

func (this *BiboFreelist15[T]) Cap() int

func (*BiboFreelist15[T]) Get

func (this *BiboFreelist15[T]) Get() (*T, bool)

func (*BiboFreelist15[T]) Len

func (this *BiboFreelist15[T]) Len() int

func (*BiboFreelist15[T]) Release

func (this *BiboFreelist15[T]) Release(id uint) bool

type BiboFreelist16

type BiboFreelist16[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist16

func NewBiboFreelist16[T any](factory func(uint) T) *BiboFreelist16[T]

func (*BiboFreelist16[T]) Cap

func (this *BiboFreelist16[T]) Cap() int

func (*BiboFreelist16[T]) Get

func (this *BiboFreelist16[T]) Get() (*T, bool)

func (*BiboFreelist16[T]) Len

func (this *BiboFreelist16[T]) Len() int

func (*BiboFreelist16[T]) Release

func (this *BiboFreelist16[T]) Release(id uint) bool

type BiboFreelist17

type BiboFreelist17[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist17

func NewBiboFreelist17[T any](factory func(uint) T) *BiboFreelist17[T]

func (*BiboFreelist17[T]) Cap

func (this *BiboFreelist17[T]) Cap() int

func (*BiboFreelist17[T]) Get

func (this *BiboFreelist17[T]) Get() (*T, bool)

func (*BiboFreelist17[T]) Len

func (this *BiboFreelist17[T]) Len() int

func (*BiboFreelist17[T]) Release

func (this *BiboFreelist17[T]) Release(id uint) bool

type BiboFreelist18

type BiboFreelist18[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist18

func NewBiboFreelist18[T any](factory func(uint) T) *BiboFreelist18[T]

func (*BiboFreelist18[T]) Cap

func (this *BiboFreelist18[T]) Cap() int

func (*BiboFreelist18[T]) Get

func (this *BiboFreelist18[T]) Get() (*T, bool)

func (*BiboFreelist18[T]) Len

func (this *BiboFreelist18[T]) Len() int

func (*BiboFreelist18[T]) Release

func (this *BiboFreelist18[T]) Release(id uint) bool

type BiboFreelist19

type BiboFreelist19[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist19

func NewBiboFreelist19[T any](factory func(uint) T) *BiboFreelist19[T]

func (*BiboFreelist19[T]) Cap

func (this *BiboFreelist19[T]) Cap() int

func (*BiboFreelist19[T]) Get

func (this *BiboFreelist19[T]) Get() (*T, bool)

func (*BiboFreelist19[T]) Len

func (this *BiboFreelist19[T]) Len() int

func (*BiboFreelist19[T]) Release

func (this *BiboFreelist19[T]) Release(id uint) bool

type BiboFreelist20

type BiboFreelist20[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist20

func NewBiboFreelist20[T any](factory func(uint) T) *BiboFreelist20[T]

func (*BiboFreelist20[T]) Cap

func (this *BiboFreelist20[T]) Cap() int

func (*BiboFreelist20[T]) Get

func (this *BiboFreelist20[T]) Get() (*T, bool)

func (*BiboFreelist20[T]) Len

func (this *BiboFreelist20[T]) Len() int

func (*BiboFreelist20[T]) Release

func (this *BiboFreelist20[T]) Release(id uint) bool

type BiboFreelist21

type BiboFreelist21[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist21

func NewBiboFreelist21[T any](factory func(uint) T) *BiboFreelist21[T]

func (*BiboFreelist21[T]) Cap

func (this *BiboFreelist21[T]) Cap() int

func (*BiboFreelist21[T]) Get

func (this *BiboFreelist21[T]) Get() (*T, bool)

func (*BiboFreelist21[T]) Len

func (this *BiboFreelist21[T]) Len() int

func (*BiboFreelist21[T]) Release

func (this *BiboFreelist21[T]) Release(id uint) bool

type BiboFreelist22

type BiboFreelist22[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist22

func NewBiboFreelist22[T any](factory func(uint) T) *BiboFreelist22[T]

func (*BiboFreelist22[T]) Cap

func (this *BiboFreelist22[T]) Cap() int

func (*BiboFreelist22[T]) Get

func (this *BiboFreelist22[T]) Get() (*T, bool)

func (*BiboFreelist22[T]) Len

func (this *BiboFreelist22[T]) Len() int

func (*BiboFreelist22[T]) Release

func (this *BiboFreelist22[T]) Release(id uint) bool

type BiboFreelist23

type BiboFreelist23[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist23

func NewBiboFreelist23[T any](factory func(uint) T) *BiboFreelist23[T]

func (*BiboFreelist23[T]) Cap

func (this *BiboFreelist23[T]) Cap() int

func (*BiboFreelist23[T]) Get

func (this *BiboFreelist23[T]) Get() (*T, bool)

func (*BiboFreelist23[T]) Len

func (this *BiboFreelist23[T]) Len() int

func (*BiboFreelist23[T]) Release

func (this *BiboFreelist23[T]) Release(id uint) bool

type BiboFreelist24

type BiboFreelist24[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist24

func NewBiboFreelist24[T any](factory func(uint) T) *BiboFreelist24[T]

func (*BiboFreelist24[T]) Cap

func (this *BiboFreelist24[T]) Cap() int

func (*BiboFreelist24[T]) Get

func (this *BiboFreelist24[T]) Get() (*T, bool)

func (*BiboFreelist24[T]) Len

func (this *BiboFreelist24[T]) Len() int

func (*BiboFreelist24[T]) Release

func (this *BiboFreelist24[T]) Release(id uint) bool

type BiboFreelist25

type BiboFreelist25[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist25

func NewBiboFreelist25[T any](factory func(uint) T) *BiboFreelist25[T]

func (*BiboFreelist25[T]) Cap

func (this *BiboFreelist25[T]) Cap() int

func (*BiboFreelist25[T]) Get

func (this *BiboFreelist25[T]) Get() (*T, bool)

func (*BiboFreelist25[T]) Len

func (this *BiboFreelist25[T]) Len() int

func (*BiboFreelist25[T]) Release

func (this *BiboFreelist25[T]) Release(id uint) bool

type BiboFreelist26

type BiboFreelist26[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist26

func NewBiboFreelist26[T any](factory func(uint) T) *BiboFreelist26[T]

func (*BiboFreelist26[T]) Cap

func (this *BiboFreelist26[T]) Cap() int

func (*BiboFreelist26[T]) Get

func (this *BiboFreelist26[T]) Get() (*T, bool)

func (*BiboFreelist26[T]) Len

func (this *BiboFreelist26[T]) Len() int

func (*BiboFreelist26[T]) Release

func (this *BiboFreelist26[T]) Release(id uint) bool

type BiboFreelist27

type BiboFreelist27[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist27

func NewBiboFreelist27[T any](factory func(uint) T) *BiboFreelist27[T]

func (*BiboFreelist27[T]) Cap

func (this *BiboFreelist27[T]) Cap() int

func (*BiboFreelist27[T]) Get

func (this *BiboFreelist27[T]) Get() (*T, bool)

func (*BiboFreelist27[T]) Len

func (this *BiboFreelist27[T]) Len() int

func (*BiboFreelist27[T]) Release

func (this *BiboFreelist27[T]) Release(id uint) bool

type BiboFreelist28

type BiboFreelist28[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist28

func NewBiboFreelist28[T any](factory func(uint) T) *BiboFreelist28[T]

func (*BiboFreelist28[T]) Cap

func (this *BiboFreelist28[T]) Cap() int

func (*BiboFreelist28[T]) Get

func (this *BiboFreelist28[T]) Get() (*T, bool)

func (*BiboFreelist28[T]) Len

func (this *BiboFreelist28[T]) Len() int

func (*BiboFreelist28[T]) Release

func (this *BiboFreelist28[T]) Release(id uint) bool

type BiboFreelist29

type BiboFreelist29[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist29

func NewBiboFreelist29[T any](factory func(uint) T) *BiboFreelist29[T]

func (*BiboFreelist29[T]) Cap

func (this *BiboFreelist29[T]) Cap() int

func (*BiboFreelist29[T]) Get

func (this *BiboFreelist29[T]) Get() (*T, bool)

func (*BiboFreelist29[T]) Len

func (this *BiboFreelist29[T]) Len() int

func (*BiboFreelist29[T]) Release

func (this *BiboFreelist29[T]) Release(id uint) bool

type BiboFreelist30

type BiboFreelist30[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist30

func NewBiboFreelist30[T any](factory func(uint) T) *BiboFreelist30[T]

func (*BiboFreelist30[T]) Cap

func (this *BiboFreelist30[T]) Cap() int

func (*BiboFreelist30[T]) Get

func (this *BiboFreelist30[T]) Get() (*T, bool)

func (*BiboFreelist30[T]) Len

func (this *BiboFreelist30[T]) Len() int

func (*BiboFreelist30[T]) Release

func (this *BiboFreelist30[T]) Release(id uint) bool

type BiboFreelist31

type BiboFreelist31[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist31

func NewBiboFreelist31[T any](factory func(uint) T) *BiboFreelist31[T]

func (*BiboFreelist31[T]) Cap

func (this *BiboFreelist31[T]) Cap() int

func (*BiboFreelist31[T]) Get

func (this *BiboFreelist31[T]) Get() (*T, bool)

func (*BiboFreelist31[T]) Len

func (this *BiboFreelist31[T]) Len() int

func (*BiboFreelist31[T]) Release

func (this *BiboFreelist31[T]) Release(id uint) bool

type BiboFreelist32

type BiboFreelist32[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist32

func NewBiboFreelist32[T any](factory func(uint) T) *BiboFreelist32[T]

func (*BiboFreelist32[T]) Cap

func (this *BiboFreelist32[T]) Cap() int

func (*BiboFreelist32[T]) Get

func (this *BiboFreelist32[T]) Get() (*T, bool)

func (*BiboFreelist32[T]) Len

func (this *BiboFreelist32[T]) Len() int

func (*BiboFreelist32[T]) Release

func (this *BiboFreelist32[T]) Release(id uint) bool

type BiboFreelist33

type BiboFreelist33[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist33

func NewBiboFreelist33[T any](factory func(uint) T) *BiboFreelist33[T]

func (*BiboFreelist33[T]) Cap

func (this *BiboFreelist33[T]) Cap() int

func (*BiboFreelist33[T]) Get

func (this *BiboFreelist33[T]) Get() (*T, bool)

func (*BiboFreelist33[T]) Len

func (this *BiboFreelist33[T]) Len() int

func (*BiboFreelist33[T]) Release

func (this *BiboFreelist33[T]) Release(id uint) bool

type BiboFreelist34

type BiboFreelist34[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist34

func NewBiboFreelist34[T any](factory func(uint) T) *BiboFreelist34[T]

func (*BiboFreelist34[T]) Cap

func (this *BiboFreelist34[T]) Cap() int

func (*BiboFreelist34[T]) Get

func (this *BiboFreelist34[T]) Get() (*T, bool)

func (*BiboFreelist34[T]) Len

func (this *BiboFreelist34[T]) Len() int

func (*BiboFreelist34[T]) Release

func (this *BiboFreelist34[T]) Release(id uint) bool

type BiboFreelist7

type BiboFreelist7[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist7

func NewBiboFreelist7[T any](factory func(uint) T) *BiboFreelist7[T]

func (*BiboFreelist7[T]) Cap

func (this *BiboFreelist7[T]) Cap() int

func (*BiboFreelist7[T]) Get

func (this *BiboFreelist7[T]) Get() (*T, bool)

func (*BiboFreelist7[T]) Len

func (this *BiboFreelist7[T]) Len() int

func (*BiboFreelist7[T]) Release

func (this *BiboFreelist7[T]) Release(id uint) bool

type BiboFreelist8

type BiboFreelist8[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist8

func NewBiboFreelist8[T any](factory func(uint) T) *BiboFreelist8[T]

func (*BiboFreelist8[T]) Cap

func (this *BiboFreelist8[T]) Cap() int

func (*BiboFreelist8[T]) Get

func (this *BiboFreelist8[T]) Get() (*T, bool)

func (*BiboFreelist8[T]) Len

func (this *BiboFreelist8[T]) Len() int

func (*BiboFreelist8[T]) Release

func (this *BiboFreelist8[T]) Release(id uint) bool

type BiboFreelist9

type BiboFreelist9[T any] struct {
	// contains filtered or unexported fields
}

func NewBiboFreelist9

func NewBiboFreelist9[T any](factory func(uint) T) *BiboFreelist9[T]

func (*BiboFreelist9[T]) Cap

func (this *BiboFreelist9[T]) Cap() int

func (*BiboFreelist9[T]) Get

func (this *BiboFreelist9[T]) Get() (*T, bool)

func (*BiboFreelist9[T]) Len

func (this *BiboFreelist9[T]) Len() int

func (*BiboFreelist9[T]) Release

func (this *BiboFreelist9[T]) Release(id uint) bool

type CoarseMap

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

func NewCoarseMap

func NewCoarseMap[K comparable, V any](capacity int) *CoarseMap[K, V]

func (*CoarseMap[K, V]) All

func (this *CoarseMap[K, V]) All() iter.Seq2[K, V]

func (*CoarseMap[K, V]) Delete

func (this *CoarseMap[K, V]) Delete(key K) error

func (*CoarseMap[K, V]) ForEach

func (this *CoarseMap[K, V]) ForEach(yield func(K, V) bool)

func (*CoarseMap[K, V]) Get

func (this *CoarseMap[K, V]) Get(key K) (V, error)

func (*CoarseMap[K, V]) Has

func (this *CoarseMap[K, V]) Has(key K) bool

func (*CoarseMap[K, V]) Set

func (this *CoarseMap[K, V]) Set(key K, value V) error

type CoarseRegistry

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

func NewCoarseRegistry

func NewCoarseRegistry[K comparable, V any](capacity int) *CoarseRegistry[K, V]

func (*CoarseRegistry[K, V]) Claim

func (this *CoarseRegistry[K, V]) Claim(key K) bool

func (*CoarseRegistry[K, V]) ClaimOrRegister

func (this *CoarseRegistry[K, V]) ClaimOrRegister(key K, new func() V) (V, bool)

func (*CoarseRegistry[K, V]) Get

func (this *CoarseRegistry[K, V]) Get(key K) (V, error)

func (*CoarseRegistry[K, V]) Release

func (this *CoarseRegistry[K, V]) Release(key K) bool

type CoarseSortedSet10

type CoarseSortedSet10[T common.Comparable[T]] struct {
	SortedSet10[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet10

func NewCoarseSortedSet10[T common.Comparable[T]]() *CoarseSortedSet10[T]

func (*CoarseSortedSet10[T]) All

func (this *CoarseSortedSet10[T]) All() iter.Seq[T]

func (*CoarseSortedSet10[T]) Delete

func (this *CoarseSortedSet10[T]) Delete(element T) error

func (*CoarseSortedSet10[T]) ForEach

func (this *CoarseSortedSet10[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet10[T]) Get

func (this *CoarseSortedSet10[T]) Get(element T) (T, error)

func (*CoarseSortedSet10[T]) Put

func (this *CoarseSortedSet10[T]) Put(element T) error

type CoarseSortedSet11

type CoarseSortedSet11[T common.Comparable[T]] struct {
	SortedSet11[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet11

func NewCoarseSortedSet11[T common.Comparable[T]]() *CoarseSortedSet11[T]

func (*CoarseSortedSet11[T]) All

func (this *CoarseSortedSet11[T]) All() iter.Seq[T]

func (*CoarseSortedSet11[T]) Delete

func (this *CoarseSortedSet11[T]) Delete(element T) error

func (*CoarseSortedSet11[T]) ForEach

func (this *CoarseSortedSet11[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet11[T]) Get

func (this *CoarseSortedSet11[T]) Get(element T) (T, error)

func (*CoarseSortedSet11[T]) Put

func (this *CoarseSortedSet11[T]) Put(element T) error

type CoarseSortedSet12

type CoarseSortedSet12[T common.Comparable[T]] struct {
	SortedSet12[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet12

func NewCoarseSortedSet12[T common.Comparable[T]]() *CoarseSortedSet12[T]

func (*CoarseSortedSet12[T]) All

func (this *CoarseSortedSet12[T]) All() iter.Seq[T]

func (*CoarseSortedSet12[T]) Delete

func (this *CoarseSortedSet12[T]) Delete(element T) error

func (*CoarseSortedSet12[T]) ForEach

func (this *CoarseSortedSet12[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet12[T]) Get

func (this *CoarseSortedSet12[T]) Get(element T) (T, error)

func (*CoarseSortedSet12[T]) Put

func (this *CoarseSortedSet12[T]) Put(element T) error

type CoarseSortedSet13

type CoarseSortedSet13[T common.Comparable[T]] struct {
	SortedSet13[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet13

func NewCoarseSortedSet13[T common.Comparable[T]]() *CoarseSortedSet13[T]

func (*CoarseSortedSet13[T]) All

func (this *CoarseSortedSet13[T]) All() iter.Seq[T]

func (*CoarseSortedSet13[T]) Delete

func (this *CoarseSortedSet13[T]) Delete(element T) error

func (*CoarseSortedSet13[T]) ForEach

func (this *CoarseSortedSet13[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet13[T]) Get

func (this *CoarseSortedSet13[T]) Get(element T) (T, error)

func (*CoarseSortedSet13[T]) Put

func (this *CoarseSortedSet13[T]) Put(element T) error

type CoarseSortedSet14

type CoarseSortedSet14[T common.Comparable[T]] struct {
	SortedSet14[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet14

func NewCoarseSortedSet14[T common.Comparable[T]]() *CoarseSortedSet14[T]

func (*CoarseSortedSet14[T]) All

func (this *CoarseSortedSet14[T]) All() iter.Seq[T]

func (*CoarseSortedSet14[T]) Delete

func (this *CoarseSortedSet14[T]) Delete(element T) error

func (*CoarseSortedSet14[T]) ForEach

func (this *CoarseSortedSet14[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet14[T]) Get

func (this *CoarseSortedSet14[T]) Get(element T) (T, error)

func (*CoarseSortedSet14[T]) Put

func (this *CoarseSortedSet14[T]) Put(element T) error

type CoarseSortedSet15

type CoarseSortedSet15[T common.Comparable[T]] struct {
	SortedSet15[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet15

func NewCoarseSortedSet15[T common.Comparable[T]]() *CoarseSortedSet15[T]

func (*CoarseSortedSet15[T]) All

func (this *CoarseSortedSet15[T]) All() iter.Seq[T]

func (*CoarseSortedSet15[T]) Delete

func (this *CoarseSortedSet15[T]) Delete(element T) error

func (*CoarseSortedSet15[T]) ForEach

func (this *CoarseSortedSet15[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet15[T]) Get

func (this *CoarseSortedSet15[T]) Get(element T) (T, error)

func (*CoarseSortedSet15[T]) Put

func (this *CoarseSortedSet15[T]) Put(element T) error

type CoarseSortedSet16

type CoarseSortedSet16[T common.Comparable[T]] struct {
	SortedSet16[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet16

func NewCoarseSortedSet16[T common.Comparable[T]]() *CoarseSortedSet16[T]

func (*CoarseSortedSet16[T]) All

func (this *CoarseSortedSet16[T]) All() iter.Seq[T]

func (*CoarseSortedSet16[T]) Delete

func (this *CoarseSortedSet16[T]) Delete(element T) error

func (*CoarseSortedSet16[T]) ForEach

func (this *CoarseSortedSet16[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet16[T]) Get

func (this *CoarseSortedSet16[T]) Get(element T) (T, error)

func (*CoarseSortedSet16[T]) Put

func (this *CoarseSortedSet16[T]) Put(element T) error

type CoarseSortedSet17

type CoarseSortedSet17[T common.Comparable[T]] struct {
	SortedSet17[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet17

func NewCoarseSortedSet17[T common.Comparable[T]]() *CoarseSortedSet17[T]

func (*CoarseSortedSet17[T]) All

func (this *CoarseSortedSet17[T]) All() iter.Seq[T]

func (*CoarseSortedSet17[T]) Delete

func (this *CoarseSortedSet17[T]) Delete(element T) error

func (*CoarseSortedSet17[T]) ForEach

func (this *CoarseSortedSet17[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet17[T]) Get

func (this *CoarseSortedSet17[T]) Get(element T) (T, error)

func (*CoarseSortedSet17[T]) Put

func (this *CoarseSortedSet17[T]) Put(element T) error

type CoarseSortedSet18

type CoarseSortedSet18[T common.Comparable[T]] struct {
	SortedSet18[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet18

func NewCoarseSortedSet18[T common.Comparable[T]]() *CoarseSortedSet18[T]

func (*CoarseSortedSet18[T]) All

func (this *CoarseSortedSet18[T]) All() iter.Seq[T]

func (*CoarseSortedSet18[T]) Delete

func (this *CoarseSortedSet18[T]) Delete(element T) error

func (*CoarseSortedSet18[T]) ForEach

func (this *CoarseSortedSet18[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet18[T]) Get

func (this *CoarseSortedSet18[T]) Get(element T) (T, error)

func (*CoarseSortedSet18[T]) Put

func (this *CoarseSortedSet18[T]) Put(element T) error

type CoarseSortedSet19

type CoarseSortedSet19[T common.Comparable[T]] struct {
	SortedSet19[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet19

func NewCoarseSortedSet19[T common.Comparable[T]]() *CoarseSortedSet19[T]

func (*CoarseSortedSet19[T]) All

func (this *CoarseSortedSet19[T]) All() iter.Seq[T]

func (*CoarseSortedSet19[T]) Delete

func (this *CoarseSortedSet19[T]) Delete(element T) error

func (*CoarseSortedSet19[T]) ForEach

func (this *CoarseSortedSet19[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet19[T]) Get

func (this *CoarseSortedSet19[T]) Get(element T) (T, error)

func (*CoarseSortedSet19[T]) Put

func (this *CoarseSortedSet19[T]) Put(element T) error

type CoarseSortedSet20

type CoarseSortedSet20[T common.Comparable[T]] struct {
	SortedSet20[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet20

func NewCoarseSortedSet20[T common.Comparable[T]]() *CoarseSortedSet20[T]

func (*CoarseSortedSet20[T]) All

func (this *CoarseSortedSet20[T]) All() iter.Seq[T]

func (*CoarseSortedSet20[T]) Delete

func (this *CoarseSortedSet20[T]) Delete(element T) error

func (*CoarseSortedSet20[T]) ForEach

func (this *CoarseSortedSet20[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet20[T]) Get

func (this *CoarseSortedSet20[T]) Get(element T) (T, error)

func (*CoarseSortedSet20[T]) Put

func (this *CoarseSortedSet20[T]) Put(element T) error

type CoarseSortedSet21

type CoarseSortedSet21[T common.Comparable[T]] struct {
	SortedSet21[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet21

func NewCoarseSortedSet21[T common.Comparable[T]]() *CoarseSortedSet21[T]

func (*CoarseSortedSet21[T]) All

func (this *CoarseSortedSet21[T]) All() iter.Seq[T]

func (*CoarseSortedSet21[T]) Delete

func (this *CoarseSortedSet21[T]) Delete(element T) error

func (*CoarseSortedSet21[T]) ForEach

func (this *CoarseSortedSet21[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet21[T]) Get

func (this *CoarseSortedSet21[T]) Get(element T) (T, error)

func (*CoarseSortedSet21[T]) Put

func (this *CoarseSortedSet21[T]) Put(element T) error

type CoarseSortedSet22

type CoarseSortedSet22[T common.Comparable[T]] struct {
	SortedSet22[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet22

func NewCoarseSortedSet22[T common.Comparable[T]]() *CoarseSortedSet22[T]

func (*CoarseSortedSet22[T]) All

func (this *CoarseSortedSet22[T]) All() iter.Seq[T]

func (*CoarseSortedSet22[T]) Delete

func (this *CoarseSortedSet22[T]) Delete(element T) error

func (*CoarseSortedSet22[T]) ForEach

func (this *CoarseSortedSet22[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet22[T]) Get

func (this *CoarseSortedSet22[T]) Get(element T) (T, error)

func (*CoarseSortedSet22[T]) Put

func (this *CoarseSortedSet22[T]) Put(element T) error

type CoarseSortedSet23

type CoarseSortedSet23[T common.Comparable[T]] struct {
	SortedSet23[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet23

func NewCoarseSortedSet23[T common.Comparable[T]]() *CoarseSortedSet23[T]

func (*CoarseSortedSet23[T]) All

func (this *CoarseSortedSet23[T]) All() iter.Seq[T]

func (*CoarseSortedSet23[T]) Delete

func (this *CoarseSortedSet23[T]) Delete(element T) error

func (*CoarseSortedSet23[T]) ForEach

func (this *CoarseSortedSet23[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet23[T]) Get

func (this *CoarseSortedSet23[T]) Get(element T) (T, error)

func (*CoarseSortedSet23[T]) Put

func (this *CoarseSortedSet23[T]) Put(element T) error

type CoarseSortedSet24

type CoarseSortedSet24[T common.Comparable[T]] struct {
	SortedSet24[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet24

func NewCoarseSortedSet24[T common.Comparable[T]]() *CoarseSortedSet24[T]

func (*CoarseSortedSet24[T]) All

func (this *CoarseSortedSet24[T]) All() iter.Seq[T]

func (*CoarseSortedSet24[T]) Delete

func (this *CoarseSortedSet24[T]) Delete(element T) error

func (*CoarseSortedSet24[T]) ForEach

func (this *CoarseSortedSet24[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet24[T]) Get

func (this *CoarseSortedSet24[T]) Get(element T) (T, error)

func (*CoarseSortedSet24[T]) Put

func (this *CoarseSortedSet24[T]) Put(element T) error

type CoarseSortedSet25

type CoarseSortedSet25[T common.Comparable[T]] struct {
	SortedSet25[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet25

func NewCoarseSortedSet25[T common.Comparable[T]]() *CoarseSortedSet25[T]

func (*CoarseSortedSet25[T]) All

func (this *CoarseSortedSet25[T]) All() iter.Seq[T]

func (*CoarseSortedSet25[T]) Delete

func (this *CoarseSortedSet25[T]) Delete(element T) error

func (*CoarseSortedSet25[T]) ForEach

func (this *CoarseSortedSet25[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet25[T]) Get

func (this *CoarseSortedSet25[T]) Get(element T) (T, error)

func (*CoarseSortedSet25[T]) Put

func (this *CoarseSortedSet25[T]) Put(element T) error

type CoarseSortedSet26

type CoarseSortedSet26[T common.Comparable[T]] struct {
	SortedSet26[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet26

func NewCoarseSortedSet26[T common.Comparable[T]]() *CoarseSortedSet26[T]

func (*CoarseSortedSet26[T]) All

func (this *CoarseSortedSet26[T]) All() iter.Seq[T]

func (*CoarseSortedSet26[T]) Delete

func (this *CoarseSortedSet26[T]) Delete(element T) error

func (*CoarseSortedSet26[T]) ForEach

func (this *CoarseSortedSet26[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet26[T]) Get

func (this *CoarseSortedSet26[T]) Get(element T) (T, error)

func (*CoarseSortedSet26[T]) Put

func (this *CoarseSortedSet26[T]) Put(element T) error

type CoarseSortedSet27

type CoarseSortedSet27[T common.Comparable[T]] struct {
	SortedSet27[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet27

func NewCoarseSortedSet27[T common.Comparable[T]]() *CoarseSortedSet27[T]

func (*CoarseSortedSet27[T]) All

func (this *CoarseSortedSet27[T]) All() iter.Seq[T]

func (*CoarseSortedSet27[T]) Delete

func (this *CoarseSortedSet27[T]) Delete(element T) error

func (*CoarseSortedSet27[T]) ForEach

func (this *CoarseSortedSet27[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet27[T]) Get

func (this *CoarseSortedSet27[T]) Get(element T) (T, error)

func (*CoarseSortedSet27[T]) Put

func (this *CoarseSortedSet27[T]) Put(element T) error

type CoarseSortedSet28

type CoarseSortedSet28[T common.Comparable[T]] struct {
	SortedSet28[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet28

func NewCoarseSortedSet28[T common.Comparable[T]]() *CoarseSortedSet28[T]

func (*CoarseSortedSet28[T]) All

func (this *CoarseSortedSet28[T]) All() iter.Seq[T]

func (*CoarseSortedSet28[T]) Delete

func (this *CoarseSortedSet28[T]) Delete(element T) error

func (*CoarseSortedSet28[T]) ForEach

func (this *CoarseSortedSet28[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet28[T]) Get

func (this *CoarseSortedSet28[T]) Get(element T) (T, error)

func (*CoarseSortedSet28[T]) Put

func (this *CoarseSortedSet28[T]) Put(element T) error

type CoarseSortedSet29

type CoarseSortedSet29[T common.Comparable[T]] struct {
	SortedSet29[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet29

func NewCoarseSortedSet29[T common.Comparable[T]]() *CoarseSortedSet29[T]

func (*CoarseSortedSet29[T]) All

func (this *CoarseSortedSet29[T]) All() iter.Seq[T]

func (*CoarseSortedSet29[T]) Delete

func (this *CoarseSortedSet29[T]) Delete(element T) error

func (*CoarseSortedSet29[T]) ForEach

func (this *CoarseSortedSet29[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet29[T]) Get

func (this *CoarseSortedSet29[T]) Get(element T) (T, error)

func (*CoarseSortedSet29[T]) Put

func (this *CoarseSortedSet29[T]) Put(element T) error

type CoarseSortedSet30

type CoarseSortedSet30[T common.Comparable[T]] struct {
	SortedSet30[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet30

func NewCoarseSortedSet30[T common.Comparable[T]]() *CoarseSortedSet30[T]

func (*CoarseSortedSet30[T]) All

func (this *CoarseSortedSet30[T]) All() iter.Seq[T]

func (*CoarseSortedSet30[T]) Delete

func (this *CoarseSortedSet30[T]) Delete(element T) error

func (*CoarseSortedSet30[T]) ForEach

func (this *CoarseSortedSet30[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet30[T]) Get

func (this *CoarseSortedSet30[T]) Get(element T) (T, error)

func (*CoarseSortedSet30[T]) Put

func (this *CoarseSortedSet30[T]) Put(element T) error

type CoarseSortedSet31

type CoarseSortedSet31[T common.Comparable[T]] struct {
	SortedSet31[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet31

func NewCoarseSortedSet31[T common.Comparable[T]]() *CoarseSortedSet31[T]

func (*CoarseSortedSet31[T]) All

func (this *CoarseSortedSet31[T]) All() iter.Seq[T]

func (*CoarseSortedSet31[T]) Delete

func (this *CoarseSortedSet31[T]) Delete(element T) error

func (*CoarseSortedSet31[T]) ForEach

func (this *CoarseSortedSet31[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet31[T]) Get

func (this *CoarseSortedSet31[T]) Get(element T) (T, error)

func (*CoarseSortedSet31[T]) Put

func (this *CoarseSortedSet31[T]) Put(element T) error

type CoarseSortedSet32

type CoarseSortedSet32[T common.Comparable[T]] struct {
	SortedSet32[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet32

func NewCoarseSortedSet32[T common.Comparable[T]]() *CoarseSortedSet32[T]

func (*CoarseSortedSet32[T]) All

func (this *CoarseSortedSet32[T]) All() iter.Seq[T]

func (*CoarseSortedSet32[T]) Delete

func (this *CoarseSortedSet32[T]) Delete(element T) error

func (*CoarseSortedSet32[T]) ForEach

func (this *CoarseSortedSet32[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet32[T]) Get

func (this *CoarseSortedSet32[T]) Get(element T) (T, error)

func (*CoarseSortedSet32[T]) Put

func (this *CoarseSortedSet32[T]) Put(element T) error

type CoarseSortedSet33

type CoarseSortedSet33[T common.Comparable[T]] struct {
	SortedSet33[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet33

func NewCoarseSortedSet33[T common.Comparable[T]]() *CoarseSortedSet33[T]

func (*CoarseSortedSet33[T]) All

func (this *CoarseSortedSet33[T]) All() iter.Seq[T]

func (*CoarseSortedSet33[T]) Delete

func (this *CoarseSortedSet33[T]) Delete(element T) error

func (*CoarseSortedSet33[T]) ForEach

func (this *CoarseSortedSet33[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet33[T]) Get

func (this *CoarseSortedSet33[T]) Get(element T) (T, error)

func (*CoarseSortedSet33[T]) Put

func (this *CoarseSortedSet33[T]) Put(element T) error

type CoarseSortedSet34

type CoarseSortedSet34[T common.Comparable[T]] struct {
	SortedSet34[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet34

func NewCoarseSortedSet34[T common.Comparable[T]]() *CoarseSortedSet34[T]

func (*CoarseSortedSet34[T]) All

func (this *CoarseSortedSet34[T]) All() iter.Seq[T]

func (*CoarseSortedSet34[T]) Delete

func (this *CoarseSortedSet34[T]) Delete(element T) error

func (*CoarseSortedSet34[T]) ForEach

func (this *CoarseSortedSet34[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet34[T]) Get

func (this *CoarseSortedSet34[T]) Get(element T) (T, error)

func (*CoarseSortedSet34[T]) Put

func (this *CoarseSortedSet34[T]) Put(element T) error

type CoarseSortedSet7

type CoarseSortedSet7[T common.Comparable[T]] struct {
	SortedSet7[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet7

func NewCoarseSortedSet7[T common.Comparable[T]]() *CoarseSortedSet7[T]

func (*CoarseSortedSet7[T]) All

func (this *CoarseSortedSet7[T]) All() iter.Seq[T]

func (*CoarseSortedSet7[T]) Delete

func (this *CoarseSortedSet7[T]) Delete(element T) error

func (*CoarseSortedSet7[T]) ForEach

func (this *CoarseSortedSet7[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet7[T]) Get

func (this *CoarseSortedSet7[T]) Get(element T) (T, error)

func (*CoarseSortedSet7[T]) Put

func (this *CoarseSortedSet7[T]) Put(element T) error

type CoarseSortedSet8

type CoarseSortedSet8[T common.Comparable[T]] struct {
	SortedSet8[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet8

func NewCoarseSortedSet8[T common.Comparable[T]]() *CoarseSortedSet8[T]

func (*CoarseSortedSet8[T]) All

func (this *CoarseSortedSet8[T]) All() iter.Seq[T]

func (*CoarseSortedSet8[T]) Delete

func (this *CoarseSortedSet8[T]) Delete(element T) error

func (*CoarseSortedSet8[T]) ForEach

func (this *CoarseSortedSet8[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet8[T]) Get

func (this *CoarseSortedSet8[T]) Get(element T) (T, error)

func (*CoarseSortedSet8[T]) Put

func (this *CoarseSortedSet8[T]) Put(element T) error

type CoarseSortedSet9

type CoarseSortedSet9[T common.Comparable[T]] struct {
	SortedSet9[T]
	// contains filtered or unexported fields
}

func NewCoarseSortedSet9

func NewCoarseSortedSet9[T common.Comparable[T]]() *CoarseSortedSet9[T]

func (*CoarseSortedSet9[T]) All

func (this *CoarseSortedSet9[T]) All() iter.Seq[T]

func (*CoarseSortedSet9[T]) Delete

func (this *CoarseSortedSet9[T]) Delete(element T) error

func (*CoarseSortedSet9[T]) ForEach

func (this *CoarseSortedSet9[T]) ForEach(yield func(T) bool)

func (*CoarseSortedSet9[T]) Get

func (this *CoarseSortedSet9[T]) Get(element T) (T, error)

func (*CoarseSortedSet9[T]) Put

func (this *CoarseSortedSet9[T]) Put(element T) error

type FifoFreelist0

type FifoFreelist0[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist0

func NewFifoFreelist0[T any](factory func(uint) T) *FifoFreelist0[T]

func (*FifoFreelist0[T]) Cap

func (this *FifoFreelist0[T]) Cap() int

func (*FifoFreelist0[T]) Get

func (this *FifoFreelist0[T]) Get() (*T, bool)

func (*FifoFreelist0[T]) Len

func (this *FifoFreelist0[T]) Len() int

func (*FifoFreelist0[T]) Release

func (this *FifoFreelist0[T]) Release(id uint) bool

type FifoFreelist1

type FifoFreelist1[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist1

func NewFifoFreelist1[T any](factory func(uint) T) *FifoFreelist1[T]

func (*FifoFreelist1[T]) Cap

func (this *FifoFreelist1[T]) Cap() int

func (*FifoFreelist1[T]) Get

func (this *FifoFreelist1[T]) Get() (*T, bool)

func (*FifoFreelist1[T]) Len

func (this *FifoFreelist1[T]) Len() int

func (*FifoFreelist1[T]) Release

func (this *FifoFreelist1[T]) Release(id uint) bool

type FifoFreelist10

type FifoFreelist10[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist10

func NewFifoFreelist10[T any](factory func(uint) T) *FifoFreelist10[T]

func (*FifoFreelist10[T]) Cap

func (this *FifoFreelist10[T]) Cap() int

func (*FifoFreelist10[T]) Get

func (this *FifoFreelist10[T]) Get() (*T, bool)

func (*FifoFreelist10[T]) Len

func (this *FifoFreelist10[T]) Len() int

func (*FifoFreelist10[T]) Release

func (this *FifoFreelist10[T]) Release(id uint) bool

type FifoFreelist11

type FifoFreelist11[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist11

func NewFifoFreelist11[T any](factory func(uint) T) *FifoFreelist11[T]

func (*FifoFreelist11[T]) Cap

func (this *FifoFreelist11[T]) Cap() int

func (*FifoFreelist11[T]) Get

func (this *FifoFreelist11[T]) Get() (*T, bool)

func (*FifoFreelist11[T]) Len

func (this *FifoFreelist11[T]) Len() int

func (*FifoFreelist11[T]) Release

func (this *FifoFreelist11[T]) Release(id uint) bool

type FifoFreelist12

type FifoFreelist12[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist12

func NewFifoFreelist12[T any](factory func(uint) T) *FifoFreelist12[T]

func (*FifoFreelist12[T]) Cap

func (this *FifoFreelist12[T]) Cap() int

func (*FifoFreelist12[T]) Get

func (this *FifoFreelist12[T]) Get() (*T, bool)

func (*FifoFreelist12[T]) Len

func (this *FifoFreelist12[T]) Len() int

func (*FifoFreelist12[T]) Release

func (this *FifoFreelist12[T]) Release(id uint) bool

type FifoFreelist13

type FifoFreelist13[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist13

func NewFifoFreelist13[T any](factory func(uint) T) *FifoFreelist13[T]

func (*FifoFreelist13[T]) Cap

func (this *FifoFreelist13[T]) Cap() int

func (*FifoFreelist13[T]) Get

func (this *FifoFreelist13[T]) Get() (*T, bool)

func (*FifoFreelist13[T]) Len

func (this *FifoFreelist13[T]) Len() int

func (*FifoFreelist13[T]) Release

func (this *FifoFreelist13[T]) Release(id uint) bool

type FifoFreelist14

type FifoFreelist14[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist14

func NewFifoFreelist14[T any](factory func(uint) T) *FifoFreelist14[T]

func (*FifoFreelist14[T]) Cap

func (this *FifoFreelist14[T]) Cap() int

func (*FifoFreelist14[T]) Get

func (this *FifoFreelist14[T]) Get() (*T, bool)

func (*FifoFreelist14[T]) Len

func (this *FifoFreelist14[T]) Len() int

func (*FifoFreelist14[T]) Release

func (this *FifoFreelist14[T]) Release(id uint) bool

type FifoFreelist15

type FifoFreelist15[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist15

func NewFifoFreelist15[T any](factory func(uint) T) *FifoFreelist15[T]

func (*FifoFreelist15[T]) Cap

func (this *FifoFreelist15[T]) Cap() int

func (*FifoFreelist15[T]) Get

func (this *FifoFreelist15[T]) Get() (*T, bool)

func (*FifoFreelist15[T]) Len

func (this *FifoFreelist15[T]) Len() int

func (*FifoFreelist15[T]) Release

func (this *FifoFreelist15[T]) Release(id uint) bool

type FifoFreelist16

type FifoFreelist16[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist16

func NewFifoFreelist16[T any](factory func(uint) T) *FifoFreelist16[T]

func (*FifoFreelist16[T]) Cap

func (this *FifoFreelist16[T]) Cap() int

func (*FifoFreelist16[T]) Get

func (this *FifoFreelist16[T]) Get() (*T, bool)

func (*FifoFreelist16[T]) Len

func (this *FifoFreelist16[T]) Len() int

func (*FifoFreelist16[T]) Release

func (this *FifoFreelist16[T]) Release(id uint) bool

type FifoFreelist17

type FifoFreelist17[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist17

func NewFifoFreelist17[T any](factory func(uint) T) *FifoFreelist17[T]

func (*FifoFreelist17[T]) Cap

func (this *FifoFreelist17[T]) Cap() int

func (*FifoFreelist17[T]) Get

func (this *FifoFreelist17[T]) Get() (*T, bool)

func (*FifoFreelist17[T]) Len

func (this *FifoFreelist17[T]) Len() int

func (*FifoFreelist17[T]) Release

func (this *FifoFreelist17[T]) Release(id uint) bool

type FifoFreelist18

type FifoFreelist18[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist18

func NewFifoFreelist18[T any](factory func(uint) T) *FifoFreelist18[T]

func (*FifoFreelist18[T]) Cap

func (this *FifoFreelist18[T]) Cap() int

func (*FifoFreelist18[T]) Get

func (this *FifoFreelist18[T]) Get() (*T, bool)

func (*FifoFreelist18[T]) Len

func (this *FifoFreelist18[T]) Len() int

func (*FifoFreelist18[T]) Release

func (this *FifoFreelist18[T]) Release(id uint) bool

type FifoFreelist19

type FifoFreelist19[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist19

func NewFifoFreelist19[T any](factory func(uint) T) *FifoFreelist19[T]

func (*FifoFreelist19[T]) Cap

func (this *FifoFreelist19[T]) Cap() int

func (*FifoFreelist19[T]) Get

func (this *FifoFreelist19[T]) Get() (*T, bool)

func (*FifoFreelist19[T]) Len

func (this *FifoFreelist19[T]) Len() int

func (*FifoFreelist19[T]) Release

func (this *FifoFreelist19[T]) Release(id uint) bool

type FifoFreelist2

type FifoFreelist2[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist2

func NewFifoFreelist2[T any](factory func(uint) T) *FifoFreelist2[T]

func (*FifoFreelist2[T]) Cap

func (this *FifoFreelist2[T]) Cap() int

func (*FifoFreelist2[T]) Get

func (this *FifoFreelist2[T]) Get() (*T, bool)

func (*FifoFreelist2[T]) Len

func (this *FifoFreelist2[T]) Len() int

func (*FifoFreelist2[T]) Release

func (this *FifoFreelist2[T]) Release(id uint) bool

type FifoFreelist20

type FifoFreelist20[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist20

func NewFifoFreelist20[T any](factory func(uint) T) *FifoFreelist20[T]

func (*FifoFreelist20[T]) Cap

func (this *FifoFreelist20[T]) Cap() int

func (*FifoFreelist20[T]) Get

func (this *FifoFreelist20[T]) Get() (*T, bool)

func (*FifoFreelist20[T]) Len

func (this *FifoFreelist20[T]) Len() int

func (*FifoFreelist20[T]) Release

func (this *FifoFreelist20[T]) Release(id uint) bool

type FifoFreelist21

type FifoFreelist21[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist21

func NewFifoFreelist21[T any](factory func(uint) T) *FifoFreelist21[T]

func (*FifoFreelist21[T]) Cap

func (this *FifoFreelist21[T]) Cap() int

func (*FifoFreelist21[T]) Get

func (this *FifoFreelist21[T]) Get() (*T, bool)

func (*FifoFreelist21[T]) Len

func (this *FifoFreelist21[T]) Len() int

func (*FifoFreelist21[T]) Release

func (this *FifoFreelist21[T]) Release(id uint) bool

type FifoFreelist22

type FifoFreelist22[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist22

func NewFifoFreelist22[T any](factory func(uint) T) *FifoFreelist22[T]

func (*FifoFreelist22[T]) Cap

func (this *FifoFreelist22[T]) Cap() int

func (*FifoFreelist22[T]) Get

func (this *FifoFreelist22[T]) Get() (*T, bool)

func (*FifoFreelist22[T]) Len

func (this *FifoFreelist22[T]) Len() int

func (*FifoFreelist22[T]) Release

func (this *FifoFreelist22[T]) Release(id uint) bool

type FifoFreelist23

type FifoFreelist23[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist23

func NewFifoFreelist23[T any](factory func(uint) T) *FifoFreelist23[T]

func (*FifoFreelist23[T]) Cap

func (this *FifoFreelist23[T]) Cap() int

func (*FifoFreelist23[T]) Get

func (this *FifoFreelist23[T]) Get() (*T, bool)

func (*FifoFreelist23[T]) Len

func (this *FifoFreelist23[T]) Len() int

func (*FifoFreelist23[T]) Release

func (this *FifoFreelist23[T]) Release(id uint) bool

type FifoFreelist24

type FifoFreelist24[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist24

func NewFifoFreelist24[T any](factory func(uint) T) *FifoFreelist24[T]

func (*FifoFreelist24[T]) Cap

func (this *FifoFreelist24[T]) Cap() int

func (*FifoFreelist24[T]) Get

func (this *FifoFreelist24[T]) Get() (*T, bool)

func (*FifoFreelist24[T]) Len

func (this *FifoFreelist24[T]) Len() int

func (*FifoFreelist24[T]) Release

func (this *FifoFreelist24[T]) Release(id uint) bool

type FifoFreelist25

type FifoFreelist25[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist25

func NewFifoFreelist25[T any](factory func(uint) T) *FifoFreelist25[T]

func (*FifoFreelist25[T]) Cap

func (this *FifoFreelist25[T]) Cap() int

func (*FifoFreelist25[T]) Get

func (this *FifoFreelist25[T]) Get() (*T, bool)

func (*FifoFreelist25[T]) Len

func (this *FifoFreelist25[T]) Len() int

func (*FifoFreelist25[T]) Release

func (this *FifoFreelist25[T]) Release(id uint) bool

type FifoFreelist26

type FifoFreelist26[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist26

func NewFifoFreelist26[T any](factory func(uint) T) *FifoFreelist26[T]

func (*FifoFreelist26[T]) Cap

func (this *FifoFreelist26[T]) Cap() int

func (*FifoFreelist26[T]) Get

func (this *FifoFreelist26[T]) Get() (*T, bool)

func (*FifoFreelist26[T]) Len

func (this *FifoFreelist26[T]) Len() int

func (*FifoFreelist26[T]) Release

func (this *FifoFreelist26[T]) Release(id uint) bool

type FifoFreelist27

type FifoFreelist27[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist27

func NewFifoFreelist27[T any](factory func(uint) T) *FifoFreelist27[T]

func (*FifoFreelist27[T]) Cap

func (this *FifoFreelist27[T]) Cap() int

func (*FifoFreelist27[T]) Get

func (this *FifoFreelist27[T]) Get() (*T, bool)

func (*FifoFreelist27[T]) Len

func (this *FifoFreelist27[T]) Len() int

func (*FifoFreelist27[T]) Release

func (this *FifoFreelist27[T]) Release(id uint) bool

type FifoFreelist28

type FifoFreelist28[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist28

func NewFifoFreelist28[T any](factory func(uint) T) *FifoFreelist28[T]

func (*FifoFreelist28[T]) Cap

func (this *FifoFreelist28[T]) Cap() int

func (*FifoFreelist28[T]) Get

func (this *FifoFreelist28[T]) Get() (*T, bool)

func (*FifoFreelist28[T]) Len

func (this *FifoFreelist28[T]) Len() int

func (*FifoFreelist28[T]) Release

func (this *FifoFreelist28[T]) Release(id uint) bool

type FifoFreelist29

type FifoFreelist29[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist29

func NewFifoFreelist29[T any](factory func(uint) T) *FifoFreelist29[T]

func (*FifoFreelist29[T]) Cap

func (this *FifoFreelist29[T]) Cap() int

func (*FifoFreelist29[T]) Get

func (this *FifoFreelist29[T]) Get() (*T, bool)

func (*FifoFreelist29[T]) Len

func (this *FifoFreelist29[T]) Len() int

func (*FifoFreelist29[T]) Release

func (this *FifoFreelist29[T]) Release(id uint) bool

type FifoFreelist3

type FifoFreelist3[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist3

func NewFifoFreelist3[T any](factory func(uint) T) *FifoFreelist3[T]

func (*FifoFreelist3[T]) Cap

func (this *FifoFreelist3[T]) Cap() int

func (*FifoFreelist3[T]) Get

func (this *FifoFreelist3[T]) Get() (*T, bool)

func (*FifoFreelist3[T]) Len

func (this *FifoFreelist3[T]) Len() int

func (*FifoFreelist3[T]) Release

func (this *FifoFreelist3[T]) Release(id uint) bool

type FifoFreelist30

type FifoFreelist30[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist30

func NewFifoFreelist30[T any](factory func(uint) T) *FifoFreelist30[T]

func (*FifoFreelist30[T]) Cap

func (this *FifoFreelist30[T]) Cap() int

func (*FifoFreelist30[T]) Get

func (this *FifoFreelist30[T]) Get() (*T, bool)

func (*FifoFreelist30[T]) Len

func (this *FifoFreelist30[T]) Len() int

func (*FifoFreelist30[T]) Release

func (this *FifoFreelist30[T]) Release(id uint) bool

type FifoFreelist31

type FifoFreelist31[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist31

func NewFifoFreelist31[T any](factory func(uint) T) *FifoFreelist31[T]

func (*FifoFreelist31[T]) Cap

func (this *FifoFreelist31[T]) Cap() int

func (*FifoFreelist31[T]) Get

func (this *FifoFreelist31[T]) Get() (*T, bool)

func (*FifoFreelist31[T]) Len

func (this *FifoFreelist31[T]) Len() int

func (*FifoFreelist31[T]) Release

func (this *FifoFreelist31[T]) Release(id uint) bool

type FifoFreelist32

type FifoFreelist32[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist32

func NewFifoFreelist32[T any](factory func(uint) T) *FifoFreelist32[T]

func (*FifoFreelist32[T]) Cap

func (this *FifoFreelist32[T]) Cap() int

func (*FifoFreelist32[T]) Get

func (this *FifoFreelist32[T]) Get() (*T, bool)

func (*FifoFreelist32[T]) Len

func (this *FifoFreelist32[T]) Len() int

func (*FifoFreelist32[T]) Release

func (this *FifoFreelist32[T]) Release(id uint) bool

type FifoFreelist33

type FifoFreelist33[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist33

func NewFifoFreelist33[T any](factory func(uint) T) *FifoFreelist33[T]

func (*FifoFreelist33[T]) Cap

func (this *FifoFreelist33[T]) Cap() int

func (*FifoFreelist33[T]) Get

func (this *FifoFreelist33[T]) Get() (*T, bool)

func (*FifoFreelist33[T]) Len

func (this *FifoFreelist33[T]) Len() int

func (*FifoFreelist33[T]) Release

func (this *FifoFreelist33[T]) Release(id uint) bool

type FifoFreelist34

type FifoFreelist34[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist34

func NewFifoFreelist34[T any](factory func(uint) T) *FifoFreelist34[T]

func (*FifoFreelist34[T]) Cap

func (this *FifoFreelist34[T]) Cap() int

func (*FifoFreelist34[T]) Get

func (this *FifoFreelist34[T]) Get() (*T, bool)

func (*FifoFreelist34[T]) Len

func (this *FifoFreelist34[T]) Len() int

func (*FifoFreelist34[T]) Release

func (this *FifoFreelist34[T]) Release(id uint) bool

type FifoFreelist4

type FifoFreelist4[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist4

func NewFifoFreelist4[T any](factory func(uint) T) *FifoFreelist4[T]

func (*FifoFreelist4[T]) Cap

func (this *FifoFreelist4[T]) Cap() int

func (*FifoFreelist4[T]) Get

func (this *FifoFreelist4[T]) Get() (*T, bool)

func (*FifoFreelist4[T]) Len

func (this *FifoFreelist4[T]) Len() int

func (*FifoFreelist4[T]) Release

func (this *FifoFreelist4[T]) Release(id uint) bool

type FifoFreelist5

type FifoFreelist5[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist5

func NewFifoFreelist5[T any](factory func(uint) T) *FifoFreelist5[T]

func (*FifoFreelist5[T]) Cap

func (this *FifoFreelist5[T]) Cap() int

func (*FifoFreelist5[T]) Get

func (this *FifoFreelist5[T]) Get() (*T, bool)

func (*FifoFreelist5[T]) Len

func (this *FifoFreelist5[T]) Len() int

func (*FifoFreelist5[T]) Release

func (this *FifoFreelist5[T]) Release(id uint) bool

type FifoFreelist6

type FifoFreelist6[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist6

func NewFifoFreelist6[T any](factory func(uint) T) *FifoFreelist6[T]

func (*FifoFreelist6[T]) Cap

func (this *FifoFreelist6[T]) Cap() int

func (*FifoFreelist6[T]) Get

func (this *FifoFreelist6[T]) Get() (*T, bool)

func (*FifoFreelist6[T]) Len

func (this *FifoFreelist6[T]) Len() int

func (*FifoFreelist6[T]) Release

func (this *FifoFreelist6[T]) Release(id uint) bool

type FifoFreelist7

type FifoFreelist7[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist7

func NewFifoFreelist7[T any](factory func(uint) T) *FifoFreelist7[T]

func (*FifoFreelist7[T]) Cap

func (this *FifoFreelist7[T]) Cap() int

func (*FifoFreelist7[T]) Get

func (this *FifoFreelist7[T]) Get() (*T, bool)

func (*FifoFreelist7[T]) Len

func (this *FifoFreelist7[T]) Len() int

func (*FifoFreelist7[T]) Release

func (this *FifoFreelist7[T]) Release(id uint) bool

type FifoFreelist8

type FifoFreelist8[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist8

func NewFifoFreelist8[T any](factory func(uint) T) *FifoFreelist8[T]

func (*FifoFreelist8[T]) Cap

func (this *FifoFreelist8[T]) Cap() int

func (*FifoFreelist8[T]) Get

func (this *FifoFreelist8[T]) Get() (*T, bool)

func (*FifoFreelist8[T]) Len

func (this *FifoFreelist8[T]) Len() int

func (*FifoFreelist8[T]) Release

func (this *FifoFreelist8[T]) Release(id uint) bool

type FifoFreelist9

type FifoFreelist9[T any] struct {
	// contains filtered or unexported fields
}

func NewFifoFreelist9

func NewFifoFreelist9[T any](factory func(uint) T) *FifoFreelist9[T]

func (*FifoFreelist9[T]) Cap

func (this *FifoFreelist9[T]) Cap() int

func (*FifoFreelist9[T]) Get

func (this *FifoFreelist9[T]) Get() (*T, bool)

func (*FifoFreelist9[T]) Len

func (this *FifoFreelist9[T]) Len() int

func (*FifoFreelist9[T]) Release

func (this *FifoFreelist9[T]) Release(id uint) bool

type LeakyHeap added in v0.9.0

type LeakyHeap[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*LeakyHeap[T]) Cap added in v0.9.0

func (this *LeakyHeap[T]) Cap() int

func (*LeakyHeap[T]) Len added in v0.9.0

func (this *LeakyHeap[T]) Len() int

func (*LeakyHeap[T]) Peek added in v0.9.0

func (this *LeakyHeap[T]) Peek() (T, bool)

func (*LeakyHeap[T]) Push added in v0.9.0

func (this *LeakyHeap[T]) Push(node T)

func (*LeakyHeap[T]) Remove added in v0.9.0

func (this *LeakyHeap[T]) Remove(node T)

type LifoFreelist0

type LifoFreelist0[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist0

func NewLifoFreelist0[T any](factory func(uint) T) *LifoFreelist0[T]

func (*LifoFreelist0[T]) Cap

func (this *LifoFreelist0[T]) Cap() int

func (*LifoFreelist0[T]) Get

func (this *LifoFreelist0[T]) Get() (*T, bool)

func (*LifoFreelist0[T]) Len

func (this *LifoFreelist0[T]) Len() int

func (*LifoFreelist0[T]) Release

func (this *LifoFreelist0[T]) Release(id uint) bool

type LifoFreelist1

type LifoFreelist1[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist1

func NewLifoFreelist1[T any](factory func(uint) T) *LifoFreelist1[T]

func (*LifoFreelist1[T]) Cap

func (this *LifoFreelist1[T]) Cap() int

func (*LifoFreelist1[T]) Get

func (this *LifoFreelist1[T]) Get() (*T, bool)

func (*LifoFreelist1[T]) Len

func (this *LifoFreelist1[T]) Len() int

func (*LifoFreelist1[T]) Release

func (this *LifoFreelist1[T]) Release(id uint) bool

type LifoFreelist10

type LifoFreelist10[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist10

func NewLifoFreelist10[T any](factory func(uint) T) *LifoFreelist10[T]

func (*LifoFreelist10[T]) Cap

func (this *LifoFreelist10[T]) Cap() int

func (*LifoFreelist10[T]) Get

func (this *LifoFreelist10[T]) Get() (*T, bool)

func (*LifoFreelist10[T]) Len

func (this *LifoFreelist10[T]) Len() int

func (*LifoFreelist10[T]) Release

func (this *LifoFreelist10[T]) Release(id uint) bool

type LifoFreelist11

type LifoFreelist11[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist11

func NewLifoFreelist11[T any](factory func(uint) T) *LifoFreelist11[T]

func (*LifoFreelist11[T]) Cap

func (this *LifoFreelist11[T]) Cap() int

func (*LifoFreelist11[T]) Get

func (this *LifoFreelist11[T]) Get() (*T, bool)

func (*LifoFreelist11[T]) Len

func (this *LifoFreelist11[T]) Len() int

func (*LifoFreelist11[T]) Release

func (this *LifoFreelist11[T]) Release(id uint) bool

type LifoFreelist12

type LifoFreelist12[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist12

func NewLifoFreelist12[T any](factory func(uint) T) *LifoFreelist12[T]

func (*LifoFreelist12[T]) Cap

func (this *LifoFreelist12[T]) Cap() int

func (*LifoFreelist12[T]) Get

func (this *LifoFreelist12[T]) Get() (*T, bool)

func (*LifoFreelist12[T]) Len

func (this *LifoFreelist12[T]) Len() int

func (*LifoFreelist12[T]) Release

func (this *LifoFreelist12[T]) Release(id uint) bool

type LifoFreelist13

type LifoFreelist13[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist13

func NewLifoFreelist13[T any](factory func(uint) T) *LifoFreelist13[T]

func (*LifoFreelist13[T]) Cap

func (this *LifoFreelist13[T]) Cap() int

func (*LifoFreelist13[T]) Get

func (this *LifoFreelist13[T]) Get() (*T, bool)

func (*LifoFreelist13[T]) Len

func (this *LifoFreelist13[T]) Len() int

func (*LifoFreelist13[T]) Release

func (this *LifoFreelist13[T]) Release(id uint) bool

type LifoFreelist14

type LifoFreelist14[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist14

func NewLifoFreelist14[T any](factory func(uint) T) *LifoFreelist14[T]

func (*LifoFreelist14[T]) Cap

func (this *LifoFreelist14[T]) Cap() int

func (*LifoFreelist14[T]) Get

func (this *LifoFreelist14[T]) Get() (*T, bool)

func (*LifoFreelist14[T]) Len

func (this *LifoFreelist14[T]) Len() int

func (*LifoFreelist14[T]) Release

func (this *LifoFreelist14[T]) Release(id uint) bool

type LifoFreelist15

type LifoFreelist15[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist15

func NewLifoFreelist15[T any](factory func(uint) T) *LifoFreelist15[T]

func (*LifoFreelist15[T]) Cap

func (this *LifoFreelist15[T]) Cap() int

func (*LifoFreelist15[T]) Get

func (this *LifoFreelist15[T]) Get() (*T, bool)

func (*LifoFreelist15[T]) Len

func (this *LifoFreelist15[T]) Len() int

func (*LifoFreelist15[T]) Release

func (this *LifoFreelist15[T]) Release(id uint) bool

type LifoFreelist16

type LifoFreelist16[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist16

func NewLifoFreelist16[T any](factory func(uint) T) *LifoFreelist16[T]

func (*LifoFreelist16[T]) Cap

func (this *LifoFreelist16[T]) Cap() int

func (*LifoFreelist16[T]) Get

func (this *LifoFreelist16[T]) Get() (*T, bool)

func (*LifoFreelist16[T]) Len

func (this *LifoFreelist16[T]) Len() int

func (*LifoFreelist16[T]) Release

func (this *LifoFreelist16[T]) Release(id uint) bool

type LifoFreelist17

type LifoFreelist17[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist17

func NewLifoFreelist17[T any](factory func(uint) T) *LifoFreelist17[T]

func (*LifoFreelist17[T]) Cap

func (this *LifoFreelist17[T]) Cap() int

func (*LifoFreelist17[T]) Get

func (this *LifoFreelist17[T]) Get() (*T, bool)

func (*LifoFreelist17[T]) Len

func (this *LifoFreelist17[T]) Len() int

func (*LifoFreelist17[T]) Release

func (this *LifoFreelist17[T]) Release(id uint) bool

type LifoFreelist18

type LifoFreelist18[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist18

func NewLifoFreelist18[T any](factory func(uint) T) *LifoFreelist18[T]

func (*LifoFreelist18[T]) Cap

func (this *LifoFreelist18[T]) Cap() int

func (*LifoFreelist18[T]) Get

func (this *LifoFreelist18[T]) Get() (*T, bool)

func (*LifoFreelist18[T]) Len

func (this *LifoFreelist18[T]) Len() int

func (*LifoFreelist18[T]) Release

func (this *LifoFreelist18[T]) Release(id uint) bool

type LifoFreelist19

type LifoFreelist19[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist19

func NewLifoFreelist19[T any](factory func(uint) T) *LifoFreelist19[T]

func (*LifoFreelist19[T]) Cap

func (this *LifoFreelist19[T]) Cap() int

func (*LifoFreelist19[T]) Get

func (this *LifoFreelist19[T]) Get() (*T, bool)

func (*LifoFreelist19[T]) Len

func (this *LifoFreelist19[T]) Len() int

func (*LifoFreelist19[T]) Release

func (this *LifoFreelist19[T]) Release(id uint) bool

type LifoFreelist2

type LifoFreelist2[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist2

func NewLifoFreelist2[T any](factory func(uint) T) *LifoFreelist2[T]

func (*LifoFreelist2[T]) Cap

func (this *LifoFreelist2[T]) Cap() int

func (*LifoFreelist2[T]) Get

func (this *LifoFreelist2[T]) Get() (*T, bool)

func (*LifoFreelist2[T]) Len

func (this *LifoFreelist2[T]) Len() int

func (*LifoFreelist2[T]) Release

func (this *LifoFreelist2[T]) Release(id uint) bool

type LifoFreelist20

type LifoFreelist20[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist20

func NewLifoFreelist20[T any](factory func(uint) T) *LifoFreelist20[T]

func (*LifoFreelist20[T]) Cap

func (this *LifoFreelist20[T]) Cap() int

func (*LifoFreelist20[T]) Get

func (this *LifoFreelist20[T]) Get() (*T, bool)

func (*LifoFreelist20[T]) Len

func (this *LifoFreelist20[T]) Len() int

func (*LifoFreelist20[T]) Release

func (this *LifoFreelist20[T]) Release(id uint) bool

type LifoFreelist21

type LifoFreelist21[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist21

func NewLifoFreelist21[T any](factory func(uint) T) *LifoFreelist21[T]

func (*LifoFreelist21[T]) Cap

func (this *LifoFreelist21[T]) Cap() int

func (*LifoFreelist21[T]) Get

func (this *LifoFreelist21[T]) Get() (*T, bool)

func (*LifoFreelist21[T]) Len

func (this *LifoFreelist21[T]) Len() int

func (*LifoFreelist21[T]) Release

func (this *LifoFreelist21[T]) Release(id uint) bool

type LifoFreelist22

type LifoFreelist22[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist22

func NewLifoFreelist22[T any](factory func(uint) T) *LifoFreelist22[T]

func (*LifoFreelist22[T]) Cap

func (this *LifoFreelist22[T]) Cap() int

func (*LifoFreelist22[T]) Get

func (this *LifoFreelist22[T]) Get() (*T, bool)

func (*LifoFreelist22[T]) Len

func (this *LifoFreelist22[T]) Len() int

func (*LifoFreelist22[T]) Release

func (this *LifoFreelist22[T]) Release(id uint) bool

type LifoFreelist23

type LifoFreelist23[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist23

func NewLifoFreelist23[T any](factory func(uint) T) *LifoFreelist23[T]

func (*LifoFreelist23[T]) Cap

func (this *LifoFreelist23[T]) Cap() int

func (*LifoFreelist23[T]) Get

func (this *LifoFreelist23[T]) Get() (*T, bool)

func (*LifoFreelist23[T]) Len

func (this *LifoFreelist23[T]) Len() int

func (*LifoFreelist23[T]) Release

func (this *LifoFreelist23[T]) Release(id uint) bool

type LifoFreelist24

type LifoFreelist24[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist24

func NewLifoFreelist24[T any](factory func(uint) T) *LifoFreelist24[T]

func (*LifoFreelist24[T]) Cap

func (this *LifoFreelist24[T]) Cap() int

func (*LifoFreelist24[T]) Get

func (this *LifoFreelist24[T]) Get() (*T, bool)

func (*LifoFreelist24[T]) Len

func (this *LifoFreelist24[T]) Len() int

func (*LifoFreelist24[T]) Release

func (this *LifoFreelist24[T]) Release(id uint) bool

type LifoFreelist25

type LifoFreelist25[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist25

func NewLifoFreelist25[T any](factory func(uint) T) *LifoFreelist25[T]

func (*LifoFreelist25[T]) Cap

func (this *LifoFreelist25[T]) Cap() int

func (*LifoFreelist25[T]) Get

func (this *LifoFreelist25[T]) Get() (*T, bool)

func (*LifoFreelist25[T]) Len

func (this *LifoFreelist25[T]) Len() int

func (*LifoFreelist25[T]) Release

func (this *LifoFreelist25[T]) Release(id uint) bool

type LifoFreelist26

type LifoFreelist26[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist26

func NewLifoFreelist26[T any](factory func(uint) T) *LifoFreelist26[T]

func (*LifoFreelist26[T]) Cap

func (this *LifoFreelist26[T]) Cap() int

func (*LifoFreelist26[T]) Get

func (this *LifoFreelist26[T]) Get() (*T, bool)

func (*LifoFreelist26[T]) Len

func (this *LifoFreelist26[T]) Len() int

func (*LifoFreelist26[T]) Release

func (this *LifoFreelist26[T]) Release(id uint) bool

type LifoFreelist27

type LifoFreelist27[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist27

func NewLifoFreelist27[T any](factory func(uint) T) *LifoFreelist27[T]

func (*LifoFreelist27[T]) Cap

func (this *LifoFreelist27[T]) Cap() int

func (*LifoFreelist27[T]) Get

func (this *LifoFreelist27[T]) Get() (*T, bool)

func (*LifoFreelist27[T]) Len

func (this *LifoFreelist27[T]) Len() int

func (*LifoFreelist27[T]) Release

func (this *LifoFreelist27[T]) Release(id uint) bool

type LifoFreelist28

type LifoFreelist28[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist28

func NewLifoFreelist28[T any](factory func(uint) T) *LifoFreelist28[T]

func (*LifoFreelist28[T]) Cap

func (this *LifoFreelist28[T]) Cap() int

func (*LifoFreelist28[T]) Get

func (this *LifoFreelist28[T]) Get() (*T, bool)

func (*LifoFreelist28[T]) Len

func (this *LifoFreelist28[T]) Len() int

func (*LifoFreelist28[T]) Release

func (this *LifoFreelist28[T]) Release(id uint) bool

type LifoFreelist29

type LifoFreelist29[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist29

func NewLifoFreelist29[T any](factory func(uint) T) *LifoFreelist29[T]

func (*LifoFreelist29[T]) Cap

func (this *LifoFreelist29[T]) Cap() int

func (*LifoFreelist29[T]) Get

func (this *LifoFreelist29[T]) Get() (*T, bool)

func (*LifoFreelist29[T]) Len

func (this *LifoFreelist29[T]) Len() int

func (*LifoFreelist29[T]) Release

func (this *LifoFreelist29[T]) Release(id uint) bool

type LifoFreelist3

type LifoFreelist3[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist3

func NewLifoFreelist3[T any](factory func(uint) T) *LifoFreelist3[T]

func (*LifoFreelist3[T]) Cap

func (this *LifoFreelist3[T]) Cap() int

func (*LifoFreelist3[T]) Get

func (this *LifoFreelist3[T]) Get() (*T, bool)

func (*LifoFreelist3[T]) Len

func (this *LifoFreelist3[T]) Len() int

func (*LifoFreelist3[T]) Release

func (this *LifoFreelist3[T]) Release(id uint) bool

type LifoFreelist30

type LifoFreelist30[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist30

func NewLifoFreelist30[T any](factory func(uint) T) *LifoFreelist30[T]

func (*LifoFreelist30[T]) Cap

func (this *LifoFreelist30[T]) Cap() int

func (*LifoFreelist30[T]) Get

func (this *LifoFreelist30[T]) Get() (*T, bool)

func (*LifoFreelist30[T]) Len

func (this *LifoFreelist30[T]) Len() int

func (*LifoFreelist30[T]) Release

func (this *LifoFreelist30[T]) Release(id uint) bool

type LifoFreelist31

type LifoFreelist31[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist31

func NewLifoFreelist31[T any](factory func(uint) T) *LifoFreelist31[T]

func (*LifoFreelist31[T]) Cap

func (this *LifoFreelist31[T]) Cap() int

func (*LifoFreelist31[T]) Get

func (this *LifoFreelist31[T]) Get() (*T, bool)

func (*LifoFreelist31[T]) Len

func (this *LifoFreelist31[T]) Len() int

func (*LifoFreelist31[T]) Release

func (this *LifoFreelist31[T]) Release(id uint) bool

type LifoFreelist32

type LifoFreelist32[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist32

func NewLifoFreelist32[T any](factory func(uint) T) *LifoFreelist32[T]

func (*LifoFreelist32[T]) Cap

func (this *LifoFreelist32[T]) Cap() int

func (*LifoFreelist32[T]) Get

func (this *LifoFreelist32[T]) Get() (*T, bool)

func (*LifoFreelist32[T]) Len

func (this *LifoFreelist32[T]) Len() int

func (*LifoFreelist32[T]) Release

func (this *LifoFreelist32[T]) Release(id uint) bool

type LifoFreelist33

type LifoFreelist33[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist33

func NewLifoFreelist33[T any](factory func(uint) T) *LifoFreelist33[T]

func (*LifoFreelist33[T]) Cap

func (this *LifoFreelist33[T]) Cap() int

func (*LifoFreelist33[T]) Get

func (this *LifoFreelist33[T]) Get() (*T, bool)

func (*LifoFreelist33[T]) Len

func (this *LifoFreelist33[T]) Len() int

func (*LifoFreelist33[T]) Release

func (this *LifoFreelist33[T]) Release(id uint) bool

type LifoFreelist34

type LifoFreelist34[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist34

func NewLifoFreelist34[T any](factory func(uint) T) *LifoFreelist34[T]

func (*LifoFreelist34[T]) Cap

func (this *LifoFreelist34[T]) Cap() int

func (*LifoFreelist34[T]) Get

func (this *LifoFreelist34[T]) Get() (*T, bool)

func (*LifoFreelist34[T]) Len

func (this *LifoFreelist34[T]) Len() int

func (*LifoFreelist34[T]) Release

func (this *LifoFreelist34[T]) Release(id uint) bool

type LifoFreelist4

type LifoFreelist4[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist4

func NewLifoFreelist4[T any](factory func(uint) T) *LifoFreelist4[T]

func (*LifoFreelist4[T]) Cap

func (this *LifoFreelist4[T]) Cap() int

func (*LifoFreelist4[T]) Get

func (this *LifoFreelist4[T]) Get() (*T, bool)

func (*LifoFreelist4[T]) Len

func (this *LifoFreelist4[T]) Len() int

func (*LifoFreelist4[T]) Release

func (this *LifoFreelist4[T]) Release(id uint) bool

type LifoFreelist5

type LifoFreelist5[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist5

func NewLifoFreelist5[T any](factory func(uint) T) *LifoFreelist5[T]

func (*LifoFreelist5[T]) Cap

func (this *LifoFreelist5[T]) Cap() int

func (*LifoFreelist5[T]) Get

func (this *LifoFreelist5[T]) Get() (*T, bool)

func (*LifoFreelist5[T]) Len

func (this *LifoFreelist5[T]) Len() int

func (*LifoFreelist5[T]) Release

func (this *LifoFreelist5[T]) Release(id uint) bool

type LifoFreelist6

type LifoFreelist6[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist6

func NewLifoFreelist6[T any](factory func(uint) T) *LifoFreelist6[T]

func (*LifoFreelist6[T]) Cap

func (this *LifoFreelist6[T]) Cap() int

func (*LifoFreelist6[T]) Get

func (this *LifoFreelist6[T]) Get() (*T, bool)

func (*LifoFreelist6[T]) Len

func (this *LifoFreelist6[T]) Len() int

func (*LifoFreelist6[T]) Release

func (this *LifoFreelist6[T]) Release(id uint) bool

type LifoFreelist7

type LifoFreelist7[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist7

func NewLifoFreelist7[T any](factory func(uint) T) *LifoFreelist7[T]

func (*LifoFreelist7[T]) Cap

func (this *LifoFreelist7[T]) Cap() int

func (*LifoFreelist7[T]) Get

func (this *LifoFreelist7[T]) Get() (*T, bool)

func (*LifoFreelist7[T]) Len

func (this *LifoFreelist7[T]) Len() int

func (*LifoFreelist7[T]) Release

func (this *LifoFreelist7[T]) Release(id uint) bool

type LifoFreelist8

type LifoFreelist8[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist8

func NewLifoFreelist8[T any](factory func(uint) T) *LifoFreelist8[T]

func (*LifoFreelist8[T]) Cap

func (this *LifoFreelist8[T]) Cap() int

func (*LifoFreelist8[T]) Get

func (this *LifoFreelist8[T]) Get() (*T, bool)

func (*LifoFreelist8[T]) Len

func (this *LifoFreelist8[T]) Len() int

func (*LifoFreelist8[T]) Release

func (this *LifoFreelist8[T]) Release(id uint) bool

type LifoFreelist9

type LifoFreelist9[T any] struct {
	// contains filtered or unexported fields
}

func NewLifoFreelist9

func NewLifoFreelist9[T any](factory func(uint) T) *LifoFreelist9[T]

func (*LifoFreelist9[T]) Cap

func (this *LifoFreelist9[T]) Cap() int

func (*LifoFreelist9[T]) Get

func (this *LifoFreelist9[T]) Get() (*T, bool)

func (*LifoFreelist9[T]) Len

func (this *LifoFreelist9[T]) Len() int

func (*LifoFreelist9[T]) Release

func (this *LifoFreelist9[T]) Release(id uint) bool

type LowfiFreelist0

type LowfiFreelist0[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist0

func NewLowfiFreelist0[T any](factory func(uint) T) *LowfiFreelist0[T]

func (*LowfiFreelist0[T]) Cap

func (this *LowfiFreelist0[T]) Cap() int

func (*LowfiFreelist0[T]) Get

func (this *LowfiFreelist0[T]) Get() (*T, bool)

func (*LowfiFreelist0[T]) Len

func (this *LowfiFreelist0[T]) Len() int

func (*LowfiFreelist0[T]) Release

func (this *LowfiFreelist0[T]) Release(id uint) bool

type LowfiFreelist1

type LowfiFreelist1[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist1

func NewLowfiFreelist1[T any](factory func(uint) T) *LowfiFreelist1[T]

func (*LowfiFreelist1[T]) Cap

func (this *LowfiFreelist1[T]) Cap() int

func (*LowfiFreelist1[T]) Get

func (this *LowfiFreelist1[T]) Get() (*T, bool)

func (*LowfiFreelist1[T]) Len

func (this *LowfiFreelist1[T]) Len() int

func (*LowfiFreelist1[T]) Release

func (this *LowfiFreelist1[T]) Release(id uint) bool

type LowfiFreelist10

type LowfiFreelist10[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist10

func NewLowfiFreelist10[T any](factory func(uint) T) *LowfiFreelist10[T]

func (*LowfiFreelist10[T]) Cap

func (this *LowfiFreelist10[T]) Cap() int

func (*LowfiFreelist10[T]) Get

func (this *LowfiFreelist10[T]) Get() (*T, bool)

func (*LowfiFreelist10[T]) Len

func (this *LowfiFreelist10[T]) Len() int

func (*LowfiFreelist10[T]) Release

func (this *LowfiFreelist10[T]) Release(id uint) bool

type LowfiFreelist11

type LowfiFreelist11[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist11

func NewLowfiFreelist11[T any](factory func(uint) T) *LowfiFreelist11[T]

func (*LowfiFreelist11[T]) Cap

func (this *LowfiFreelist11[T]) Cap() int

func (*LowfiFreelist11[T]) Get

func (this *LowfiFreelist11[T]) Get() (*T, bool)

func (*LowfiFreelist11[T]) Len

func (this *LowfiFreelist11[T]) Len() int

func (*LowfiFreelist11[T]) Release

func (this *LowfiFreelist11[T]) Release(id uint) bool

type LowfiFreelist12

type LowfiFreelist12[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist12

func NewLowfiFreelist12[T any](factory func(uint) T) *LowfiFreelist12[T]

func (*LowfiFreelist12[T]) Cap

func (this *LowfiFreelist12[T]) Cap() int

func (*LowfiFreelist12[T]) Get

func (this *LowfiFreelist12[T]) Get() (*T, bool)

func (*LowfiFreelist12[T]) Len

func (this *LowfiFreelist12[T]) Len() int

func (*LowfiFreelist12[T]) Release

func (this *LowfiFreelist12[T]) Release(id uint) bool

type LowfiFreelist13

type LowfiFreelist13[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist13

func NewLowfiFreelist13[T any](factory func(uint) T) *LowfiFreelist13[T]

func (*LowfiFreelist13[T]) Cap

func (this *LowfiFreelist13[T]) Cap() int

func (*LowfiFreelist13[T]) Get

func (this *LowfiFreelist13[T]) Get() (*T, bool)

func (*LowfiFreelist13[T]) Len

func (this *LowfiFreelist13[T]) Len() int

func (*LowfiFreelist13[T]) Release

func (this *LowfiFreelist13[T]) Release(id uint) bool

type LowfiFreelist14

type LowfiFreelist14[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist14

func NewLowfiFreelist14[T any](factory func(uint) T) *LowfiFreelist14[T]

func (*LowfiFreelist14[T]) Cap

func (this *LowfiFreelist14[T]) Cap() int

func (*LowfiFreelist14[T]) Get

func (this *LowfiFreelist14[T]) Get() (*T, bool)

func (*LowfiFreelist14[T]) Len

func (this *LowfiFreelist14[T]) Len() int

func (*LowfiFreelist14[T]) Release

func (this *LowfiFreelist14[T]) Release(id uint) bool

type LowfiFreelist15

type LowfiFreelist15[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist15

func NewLowfiFreelist15[T any](factory func(uint) T) *LowfiFreelist15[T]

func (*LowfiFreelist15[T]) Cap

func (this *LowfiFreelist15[T]) Cap() int

func (*LowfiFreelist15[T]) Get

func (this *LowfiFreelist15[T]) Get() (*T, bool)

func (*LowfiFreelist15[T]) Len

func (this *LowfiFreelist15[T]) Len() int

func (*LowfiFreelist15[T]) Release

func (this *LowfiFreelist15[T]) Release(id uint) bool

type LowfiFreelist16

type LowfiFreelist16[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist16

func NewLowfiFreelist16[T any](factory func(uint) T) *LowfiFreelist16[T]

func (*LowfiFreelist16[T]) Cap

func (this *LowfiFreelist16[T]) Cap() int

func (*LowfiFreelist16[T]) Get

func (this *LowfiFreelist16[T]) Get() (*T, bool)

func (*LowfiFreelist16[T]) Len

func (this *LowfiFreelist16[T]) Len() int

func (*LowfiFreelist16[T]) Release

func (this *LowfiFreelist16[T]) Release(id uint) bool

type LowfiFreelist17

type LowfiFreelist17[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist17

func NewLowfiFreelist17[T any](factory func(uint) T) *LowfiFreelist17[T]

func (*LowfiFreelist17[T]) Cap

func (this *LowfiFreelist17[T]) Cap() int

func (*LowfiFreelist17[T]) Get

func (this *LowfiFreelist17[T]) Get() (*T, bool)

func (*LowfiFreelist17[T]) Len

func (this *LowfiFreelist17[T]) Len() int

func (*LowfiFreelist17[T]) Release

func (this *LowfiFreelist17[T]) Release(id uint) bool

type LowfiFreelist18

type LowfiFreelist18[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist18

func NewLowfiFreelist18[T any](factory func(uint) T) *LowfiFreelist18[T]

func (*LowfiFreelist18[T]) Cap

func (this *LowfiFreelist18[T]) Cap() int

func (*LowfiFreelist18[T]) Get

func (this *LowfiFreelist18[T]) Get() (*T, bool)

func (*LowfiFreelist18[T]) Len

func (this *LowfiFreelist18[T]) Len() int

func (*LowfiFreelist18[T]) Release

func (this *LowfiFreelist18[T]) Release(id uint) bool

type LowfiFreelist19

type LowfiFreelist19[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist19

func NewLowfiFreelist19[T any](factory func(uint) T) *LowfiFreelist19[T]

func (*LowfiFreelist19[T]) Cap

func (this *LowfiFreelist19[T]) Cap() int

func (*LowfiFreelist19[T]) Get

func (this *LowfiFreelist19[T]) Get() (*T, bool)

func (*LowfiFreelist19[T]) Len

func (this *LowfiFreelist19[T]) Len() int

func (*LowfiFreelist19[T]) Release

func (this *LowfiFreelist19[T]) Release(id uint) bool

type LowfiFreelist2

type LowfiFreelist2[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist2

func NewLowfiFreelist2[T any](factory func(uint) T) *LowfiFreelist2[T]

func (*LowfiFreelist2[T]) Cap

func (this *LowfiFreelist2[T]) Cap() int

func (*LowfiFreelist2[T]) Get

func (this *LowfiFreelist2[T]) Get() (*T, bool)

func (*LowfiFreelist2[T]) Len

func (this *LowfiFreelist2[T]) Len() int

func (*LowfiFreelist2[T]) Release

func (this *LowfiFreelist2[T]) Release(id uint) bool

type LowfiFreelist20

type LowfiFreelist20[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist20

func NewLowfiFreelist20[T any](factory func(uint) T) *LowfiFreelist20[T]

func (*LowfiFreelist20[T]) Cap

func (this *LowfiFreelist20[T]) Cap() int

func (*LowfiFreelist20[T]) Get

func (this *LowfiFreelist20[T]) Get() (*T, bool)

func (*LowfiFreelist20[T]) Len

func (this *LowfiFreelist20[T]) Len() int

func (*LowfiFreelist20[T]) Release

func (this *LowfiFreelist20[T]) Release(id uint) bool

type LowfiFreelist21

type LowfiFreelist21[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist21

func NewLowfiFreelist21[T any](factory func(uint) T) *LowfiFreelist21[T]

func (*LowfiFreelist21[T]) Cap

func (this *LowfiFreelist21[T]) Cap() int

func (*LowfiFreelist21[T]) Get

func (this *LowfiFreelist21[T]) Get() (*T, bool)

func (*LowfiFreelist21[T]) Len

func (this *LowfiFreelist21[T]) Len() int

func (*LowfiFreelist21[T]) Release

func (this *LowfiFreelist21[T]) Release(id uint) bool

type LowfiFreelist22

type LowfiFreelist22[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist22

func NewLowfiFreelist22[T any](factory func(uint) T) *LowfiFreelist22[T]

func (*LowfiFreelist22[T]) Cap

func (this *LowfiFreelist22[T]) Cap() int

func (*LowfiFreelist22[T]) Get

func (this *LowfiFreelist22[T]) Get() (*T, bool)

func (*LowfiFreelist22[T]) Len

func (this *LowfiFreelist22[T]) Len() int

func (*LowfiFreelist22[T]) Release

func (this *LowfiFreelist22[T]) Release(id uint) bool

type LowfiFreelist23

type LowfiFreelist23[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist23

func NewLowfiFreelist23[T any](factory func(uint) T) *LowfiFreelist23[T]

func (*LowfiFreelist23[T]) Cap

func (this *LowfiFreelist23[T]) Cap() int

func (*LowfiFreelist23[T]) Get

func (this *LowfiFreelist23[T]) Get() (*T, bool)

func (*LowfiFreelist23[T]) Len

func (this *LowfiFreelist23[T]) Len() int

func (*LowfiFreelist23[T]) Release

func (this *LowfiFreelist23[T]) Release(id uint) bool

type LowfiFreelist24

type LowfiFreelist24[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist24

func NewLowfiFreelist24[T any](factory func(uint) T) *LowfiFreelist24[T]

func (*LowfiFreelist24[T]) Cap

func (this *LowfiFreelist24[T]) Cap() int

func (*LowfiFreelist24[T]) Get

func (this *LowfiFreelist24[T]) Get() (*T, bool)

func (*LowfiFreelist24[T]) Len

func (this *LowfiFreelist24[T]) Len() int

func (*LowfiFreelist24[T]) Release

func (this *LowfiFreelist24[T]) Release(id uint) bool

type LowfiFreelist25

type LowfiFreelist25[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist25

func NewLowfiFreelist25[T any](factory func(uint) T) *LowfiFreelist25[T]

func (*LowfiFreelist25[T]) Cap

func (this *LowfiFreelist25[T]) Cap() int

func (*LowfiFreelist25[T]) Get

func (this *LowfiFreelist25[T]) Get() (*T, bool)

func (*LowfiFreelist25[T]) Len

func (this *LowfiFreelist25[T]) Len() int

func (*LowfiFreelist25[T]) Release

func (this *LowfiFreelist25[T]) Release(id uint) bool

type LowfiFreelist26

type LowfiFreelist26[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist26

func NewLowfiFreelist26[T any](factory func(uint) T) *LowfiFreelist26[T]

func (*LowfiFreelist26[T]) Cap

func (this *LowfiFreelist26[T]) Cap() int

func (*LowfiFreelist26[T]) Get

func (this *LowfiFreelist26[T]) Get() (*T, bool)

func (*LowfiFreelist26[T]) Len

func (this *LowfiFreelist26[T]) Len() int

func (*LowfiFreelist26[T]) Release

func (this *LowfiFreelist26[T]) Release(id uint) bool

type LowfiFreelist27

type LowfiFreelist27[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist27

func NewLowfiFreelist27[T any](factory func(uint) T) *LowfiFreelist27[T]

func (*LowfiFreelist27[T]) Cap

func (this *LowfiFreelist27[T]) Cap() int

func (*LowfiFreelist27[T]) Get

func (this *LowfiFreelist27[T]) Get() (*T, bool)

func (*LowfiFreelist27[T]) Len

func (this *LowfiFreelist27[T]) Len() int

func (*LowfiFreelist27[T]) Release

func (this *LowfiFreelist27[T]) Release(id uint) bool

type LowfiFreelist28

type LowfiFreelist28[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist28

func NewLowfiFreelist28[T any](factory func(uint) T) *LowfiFreelist28[T]

func (*LowfiFreelist28[T]) Cap

func (this *LowfiFreelist28[T]) Cap() int

func (*LowfiFreelist28[T]) Get

func (this *LowfiFreelist28[T]) Get() (*T, bool)

func (*LowfiFreelist28[T]) Len

func (this *LowfiFreelist28[T]) Len() int

func (*LowfiFreelist28[T]) Release

func (this *LowfiFreelist28[T]) Release(id uint) bool

type LowfiFreelist29

type LowfiFreelist29[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist29

func NewLowfiFreelist29[T any](factory func(uint) T) *LowfiFreelist29[T]

func (*LowfiFreelist29[T]) Cap

func (this *LowfiFreelist29[T]) Cap() int

func (*LowfiFreelist29[T]) Get

func (this *LowfiFreelist29[T]) Get() (*T, bool)

func (*LowfiFreelist29[T]) Len

func (this *LowfiFreelist29[T]) Len() int

func (*LowfiFreelist29[T]) Release

func (this *LowfiFreelist29[T]) Release(id uint) bool

type LowfiFreelist3

type LowfiFreelist3[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist3

func NewLowfiFreelist3[T any](factory func(uint) T) *LowfiFreelist3[T]

func (*LowfiFreelist3[T]) Cap

func (this *LowfiFreelist3[T]) Cap() int

func (*LowfiFreelist3[T]) Get

func (this *LowfiFreelist3[T]) Get() (*T, bool)

func (*LowfiFreelist3[T]) Len

func (this *LowfiFreelist3[T]) Len() int

func (*LowfiFreelist3[T]) Release

func (this *LowfiFreelist3[T]) Release(id uint) bool

type LowfiFreelist30

type LowfiFreelist30[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist30

func NewLowfiFreelist30[T any](factory func(uint) T) *LowfiFreelist30[T]

func (*LowfiFreelist30[T]) Cap

func (this *LowfiFreelist30[T]) Cap() int

func (*LowfiFreelist30[T]) Get

func (this *LowfiFreelist30[T]) Get() (*T, bool)

func (*LowfiFreelist30[T]) Len

func (this *LowfiFreelist30[T]) Len() int

func (*LowfiFreelist30[T]) Release

func (this *LowfiFreelist30[T]) Release(id uint) bool

type LowfiFreelist31

type LowfiFreelist31[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist31

func NewLowfiFreelist31[T any](factory func(uint) T) *LowfiFreelist31[T]

func (*LowfiFreelist31[T]) Cap

func (this *LowfiFreelist31[T]) Cap() int

func (*LowfiFreelist31[T]) Get

func (this *LowfiFreelist31[T]) Get() (*T, bool)

func (*LowfiFreelist31[T]) Len

func (this *LowfiFreelist31[T]) Len() int

func (*LowfiFreelist31[T]) Release

func (this *LowfiFreelist31[T]) Release(id uint) bool

type LowfiFreelist32

type LowfiFreelist32[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist32

func NewLowfiFreelist32[T any](factory func(uint) T) *LowfiFreelist32[T]

func (*LowfiFreelist32[T]) Cap

func (this *LowfiFreelist32[T]) Cap() int

func (*LowfiFreelist32[T]) Get

func (this *LowfiFreelist32[T]) Get() (*T, bool)

func (*LowfiFreelist32[T]) Len

func (this *LowfiFreelist32[T]) Len() int

func (*LowfiFreelist32[T]) Release

func (this *LowfiFreelist32[T]) Release(id uint) bool

type LowfiFreelist33

type LowfiFreelist33[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist33

func NewLowfiFreelist33[T any](factory func(uint) T) *LowfiFreelist33[T]

func (*LowfiFreelist33[T]) Cap

func (this *LowfiFreelist33[T]) Cap() int

func (*LowfiFreelist33[T]) Get

func (this *LowfiFreelist33[T]) Get() (*T, bool)

func (*LowfiFreelist33[T]) Len

func (this *LowfiFreelist33[T]) Len() int

func (*LowfiFreelist33[T]) Release

func (this *LowfiFreelist33[T]) Release(id uint) bool

type LowfiFreelist34

type LowfiFreelist34[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist34

func NewLowfiFreelist34[T any](factory func(uint) T) *LowfiFreelist34[T]

func (*LowfiFreelist34[T]) Cap

func (this *LowfiFreelist34[T]) Cap() int

func (*LowfiFreelist34[T]) Get

func (this *LowfiFreelist34[T]) Get() (*T, bool)

func (*LowfiFreelist34[T]) Len

func (this *LowfiFreelist34[T]) Len() int

func (*LowfiFreelist34[T]) Release

func (this *LowfiFreelist34[T]) Release(id uint) bool

type LowfiFreelist4

type LowfiFreelist4[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist4

func NewLowfiFreelist4[T any](factory func(uint) T) *LowfiFreelist4[T]

func (*LowfiFreelist4[T]) Cap

func (this *LowfiFreelist4[T]) Cap() int

func (*LowfiFreelist4[T]) Get

func (this *LowfiFreelist4[T]) Get() (*T, bool)

func (*LowfiFreelist4[T]) Len

func (this *LowfiFreelist4[T]) Len() int

func (*LowfiFreelist4[T]) Release

func (this *LowfiFreelist4[T]) Release(id uint) bool

type LowfiFreelist5

type LowfiFreelist5[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist5

func NewLowfiFreelist5[T any](factory func(uint) T) *LowfiFreelist5[T]

func (*LowfiFreelist5[T]) Cap

func (this *LowfiFreelist5[T]) Cap() int

func (*LowfiFreelist5[T]) Get

func (this *LowfiFreelist5[T]) Get() (*T, bool)

func (*LowfiFreelist5[T]) Len

func (this *LowfiFreelist5[T]) Len() int

func (*LowfiFreelist5[T]) Release

func (this *LowfiFreelist5[T]) Release(id uint) bool

type LowfiFreelist6

type LowfiFreelist6[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist6

func NewLowfiFreelist6[T any](factory func(uint) T) *LowfiFreelist6[T]

func (*LowfiFreelist6[T]) Cap

func (this *LowfiFreelist6[T]) Cap() int

func (*LowfiFreelist6[T]) Get

func (this *LowfiFreelist6[T]) Get() (*T, bool)

func (*LowfiFreelist6[T]) Len

func (this *LowfiFreelist6[T]) Len() int

func (*LowfiFreelist6[T]) Release

func (this *LowfiFreelist6[T]) Release(id uint) bool

type LowfiFreelist7

type LowfiFreelist7[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist7

func NewLowfiFreelist7[T any](factory func(uint) T) *LowfiFreelist7[T]

func (*LowfiFreelist7[T]) Cap

func (this *LowfiFreelist7[T]) Cap() int

func (*LowfiFreelist7[T]) Get

func (this *LowfiFreelist7[T]) Get() (*T, bool)

func (*LowfiFreelist7[T]) Len

func (this *LowfiFreelist7[T]) Len() int

func (*LowfiFreelist7[T]) Release

func (this *LowfiFreelist7[T]) Release(id uint) bool

type LowfiFreelist8

type LowfiFreelist8[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist8

func NewLowfiFreelist8[T any](factory func(uint) T) *LowfiFreelist8[T]

func (*LowfiFreelist8[T]) Cap

func (this *LowfiFreelist8[T]) Cap() int

func (*LowfiFreelist8[T]) Get

func (this *LowfiFreelist8[T]) Get() (*T, bool)

func (*LowfiFreelist8[T]) Len

func (this *LowfiFreelist8[T]) Len() int

func (*LowfiFreelist8[T]) Release

func (this *LowfiFreelist8[T]) Release(id uint) bool

type LowfiFreelist9

type LowfiFreelist9[T any] struct {
	// contains filtered or unexported fields
}

func NewLowfiFreelist9

func NewLowfiFreelist9[T any](factory func(uint) T) *LowfiFreelist9[T]

func (*LowfiFreelist9[T]) Cap

func (this *LowfiFreelist9[T]) Cap() int

func (*LowfiFreelist9[T]) Get

func (this *LowfiFreelist9[T]) Get() (*T, bool)

func (*LowfiFreelist9[T]) Len

func (this *LowfiFreelist9[T]) Len() int

func (*LowfiFreelist9[T]) Release

func (this *LowfiFreelist9[T]) Release(id uint) bool

type Ring1

type Ring1[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring1[T]) Cap

func (this *Ring1[T]) Cap() int

func (*Ring1[T]) Len

func (this *Ring1[T]) Len() int

func (*Ring1[T]) Peek

func (this *Ring1[T]) Peek() (T, bool)

func (*Ring1[T]) Pop

func (this *Ring1[T]) Pop() (T, bool)

func (*Ring1[T]) Push

func (this *Ring1[T]) Push(element T) bool

func (*Ring1[T]) Remove

func (this *Ring1[T]) Remove(T) bool

type Ring10

type Ring10[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring10[T]) Cap

func (this *Ring10[T]) Cap() int

func (*Ring10[T]) Len

func (this *Ring10[T]) Len() int

func (*Ring10[T]) Peek

func (this *Ring10[T]) Peek() (T, bool)

func (*Ring10[T]) Pop

func (this *Ring10[T]) Pop() (T, bool)

func (*Ring10[T]) Push

func (this *Ring10[T]) Push(element T) bool

func (*Ring10[T]) Remove

func (this *Ring10[T]) Remove(T) bool

type Ring11

type Ring11[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring11[T]) Cap

func (this *Ring11[T]) Cap() int

func (*Ring11[T]) Len

func (this *Ring11[T]) Len() int

func (*Ring11[T]) Peek

func (this *Ring11[T]) Peek() (T, bool)

func (*Ring11[T]) Pop

func (this *Ring11[T]) Pop() (T, bool)

func (*Ring11[T]) Push

func (this *Ring11[T]) Push(element T) bool

func (*Ring11[T]) Remove

func (this *Ring11[T]) Remove(T) bool

type Ring12

type Ring12[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring12[T]) Cap

func (this *Ring12[T]) Cap() int

func (*Ring12[T]) Len

func (this *Ring12[T]) Len() int

func (*Ring12[T]) Peek

func (this *Ring12[T]) Peek() (T, bool)

func (*Ring12[T]) Pop

func (this *Ring12[T]) Pop() (T, bool)

func (*Ring12[T]) Push

func (this *Ring12[T]) Push(element T) bool

func (*Ring12[T]) Remove

func (this *Ring12[T]) Remove(T) bool

type Ring13

type Ring13[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring13[T]) Cap

func (this *Ring13[T]) Cap() int

func (*Ring13[T]) Len

func (this *Ring13[T]) Len() int

func (*Ring13[T]) Peek

func (this *Ring13[T]) Peek() (T, bool)

func (*Ring13[T]) Pop

func (this *Ring13[T]) Pop() (T, bool)

func (*Ring13[T]) Push

func (this *Ring13[T]) Push(element T) bool

func (*Ring13[T]) Remove

func (this *Ring13[T]) Remove(T) bool

type Ring14

type Ring14[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring14[T]) Cap

func (this *Ring14[T]) Cap() int

func (*Ring14[T]) Len

func (this *Ring14[T]) Len() int

func (*Ring14[T]) Peek

func (this *Ring14[T]) Peek() (T, bool)

func (*Ring14[T]) Pop

func (this *Ring14[T]) Pop() (T, bool)

func (*Ring14[T]) Push

func (this *Ring14[T]) Push(element T) bool

func (*Ring14[T]) Remove

func (this *Ring14[T]) Remove(T) bool

type Ring15

type Ring15[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring15[T]) Cap

func (this *Ring15[T]) Cap() int

func (*Ring15[T]) Len

func (this *Ring15[T]) Len() int

func (*Ring15[T]) Peek

func (this *Ring15[T]) Peek() (T, bool)

func (*Ring15[T]) Pop

func (this *Ring15[T]) Pop() (T, bool)

func (*Ring15[T]) Push

func (this *Ring15[T]) Push(element T) bool

func (*Ring15[T]) Remove

func (this *Ring15[T]) Remove(T) bool

type Ring16

type Ring16[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring16[T]) Cap

func (this *Ring16[T]) Cap() int

func (*Ring16[T]) Len

func (this *Ring16[T]) Len() int

func (*Ring16[T]) Peek

func (this *Ring16[T]) Peek() (T, bool)

func (*Ring16[T]) Pop

func (this *Ring16[T]) Pop() (T, bool)

func (*Ring16[T]) Push

func (this *Ring16[T]) Push(element T) bool

func (*Ring16[T]) Remove

func (this *Ring16[T]) Remove(T) bool

type Ring17

type Ring17[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring17[T]) Cap

func (this *Ring17[T]) Cap() int

func (*Ring17[T]) Len

func (this *Ring17[T]) Len() int

func (*Ring17[T]) Peek

func (this *Ring17[T]) Peek() (T, bool)

func (*Ring17[T]) Pop

func (this *Ring17[T]) Pop() (T, bool)

func (*Ring17[T]) Push

func (this *Ring17[T]) Push(element T) bool

func (*Ring17[T]) Remove

func (this *Ring17[T]) Remove(T) bool

type Ring18

type Ring18[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring18[T]) Cap

func (this *Ring18[T]) Cap() int

func (*Ring18[T]) Len

func (this *Ring18[T]) Len() int

func (*Ring18[T]) Peek

func (this *Ring18[T]) Peek() (T, bool)

func (*Ring18[T]) Pop

func (this *Ring18[T]) Pop() (T, bool)

func (*Ring18[T]) Push

func (this *Ring18[T]) Push(element T) bool

func (*Ring18[T]) Remove

func (this *Ring18[T]) Remove(T) bool

type Ring19

type Ring19[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring19[T]) Cap

func (this *Ring19[T]) Cap() int

func (*Ring19[T]) Len

func (this *Ring19[T]) Len() int

func (*Ring19[T]) Peek

func (this *Ring19[T]) Peek() (T, bool)

func (*Ring19[T]) Pop

func (this *Ring19[T]) Pop() (T, bool)

func (*Ring19[T]) Push

func (this *Ring19[T]) Push(element T) bool

func (*Ring19[T]) Remove

func (this *Ring19[T]) Remove(T) bool

type Ring2

type Ring2[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring2[T]) Cap

func (this *Ring2[T]) Cap() int

func (*Ring2[T]) Len

func (this *Ring2[T]) Len() int

func (*Ring2[T]) Peek

func (this *Ring2[T]) Peek() (T, bool)

func (*Ring2[T]) Pop

func (this *Ring2[T]) Pop() (T, bool)

func (*Ring2[T]) Push

func (this *Ring2[T]) Push(element T) bool

func (*Ring2[T]) Remove

func (this *Ring2[T]) Remove(T) bool

type Ring20

type Ring20[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring20[T]) Cap

func (this *Ring20[T]) Cap() int

func (*Ring20[T]) Len

func (this *Ring20[T]) Len() int

func (*Ring20[T]) Peek

func (this *Ring20[T]) Peek() (T, bool)

func (*Ring20[T]) Pop

func (this *Ring20[T]) Pop() (T, bool)

func (*Ring20[T]) Push

func (this *Ring20[T]) Push(element T) bool

func (*Ring20[T]) Remove

func (this *Ring20[T]) Remove(T) bool

type Ring21

type Ring21[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring21[T]) Cap

func (this *Ring21[T]) Cap() int

func (*Ring21[T]) Len

func (this *Ring21[T]) Len() int

func (*Ring21[T]) Peek

func (this *Ring21[T]) Peek() (T, bool)

func (*Ring21[T]) Pop

func (this *Ring21[T]) Pop() (T, bool)

func (*Ring21[T]) Push

func (this *Ring21[T]) Push(element T) bool

func (*Ring21[T]) Remove

func (this *Ring21[T]) Remove(T) bool

type Ring22

type Ring22[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring22[T]) Cap

func (this *Ring22[T]) Cap() int

func (*Ring22[T]) Len

func (this *Ring22[T]) Len() int

func (*Ring22[T]) Peek

func (this *Ring22[T]) Peek() (T, bool)

func (*Ring22[T]) Pop

func (this *Ring22[T]) Pop() (T, bool)

func (*Ring22[T]) Push

func (this *Ring22[T]) Push(element T) bool

func (*Ring22[T]) Remove

func (this *Ring22[T]) Remove(T) bool

type Ring23

type Ring23[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring23[T]) Cap

func (this *Ring23[T]) Cap() int

func (*Ring23[T]) Len

func (this *Ring23[T]) Len() int

func (*Ring23[T]) Peek

func (this *Ring23[T]) Peek() (T, bool)

func (*Ring23[T]) Pop

func (this *Ring23[T]) Pop() (T, bool)

func (*Ring23[T]) Push

func (this *Ring23[T]) Push(element T) bool

func (*Ring23[T]) Remove

func (this *Ring23[T]) Remove(T) bool

type Ring24

type Ring24[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring24[T]) Cap

func (this *Ring24[T]) Cap() int

func (*Ring24[T]) Len

func (this *Ring24[T]) Len() int

func (*Ring24[T]) Peek

func (this *Ring24[T]) Peek() (T, bool)

func (*Ring24[T]) Pop

func (this *Ring24[T]) Pop() (T, bool)

func (*Ring24[T]) Push

func (this *Ring24[T]) Push(element T) bool

func (*Ring24[T]) Remove

func (this *Ring24[T]) Remove(T) bool

type Ring25

type Ring25[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring25[T]) Cap

func (this *Ring25[T]) Cap() int

func (*Ring25[T]) Len

func (this *Ring25[T]) Len() int

func (*Ring25[T]) Peek

func (this *Ring25[T]) Peek() (T, bool)

func (*Ring25[T]) Pop

func (this *Ring25[T]) Pop() (T, bool)

func (*Ring25[T]) Push

func (this *Ring25[T]) Push(element T) bool

func (*Ring25[T]) Remove

func (this *Ring25[T]) Remove(T) bool

type Ring26

type Ring26[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring26[T]) Cap

func (this *Ring26[T]) Cap() int

func (*Ring26[T]) Len

func (this *Ring26[T]) Len() int

func (*Ring26[T]) Peek

func (this *Ring26[T]) Peek() (T, bool)

func (*Ring26[T]) Pop

func (this *Ring26[T]) Pop() (T, bool)

func (*Ring26[T]) Push

func (this *Ring26[T]) Push(element T) bool

func (*Ring26[T]) Remove

func (this *Ring26[T]) Remove(T) bool

type Ring27

type Ring27[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring27[T]) Cap

func (this *Ring27[T]) Cap() int

func (*Ring27[T]) Len

func (this *Ring27[T]) Len() int

func (*Ring27[T]) Peek

func (this *Ring27[T]) Peek() (T, bool)

func (*Ring27[T]) Pop

func (this *Ring27[T]) Pop() (T, bool)

func (*Ring27[T]) Push

func (this *Ring27[T]) Push(element T) bool

func (*Ring27[T]) Remove

func (this *Ring27[T]) Remove(T) bool

type Ring28

type Ring28[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring28[T]) Cap

func (this *Ring28[T]) Cap() int

func (*Ring28[T]) Len

func (this *Ring28[T]) Len() int

func (*Ring28[T]) Peek

func (this *Ring28[T]) Peek() (T, bool)

func (*Ring28[T]) Pop

func (this *Ring28[T]) Pop() (T, bool)

func (*Ring28[T]) Push

func (this *Ring28[T]) Push(element T) bool

func (*Ring28[T]) Remove

func (this *Ring28[T]) Remove(T) bool

type Ring29

type Ring29[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring29[T]) Cap

func (this *Ring29[T]) Cap() int

func (*Ring29[T]) Len

func (this *Ring29[T]) Len() int

func (*Ring29[T]) Peek

func (this *Ring29[T]) Peek() (T, bool)

func (*Ring29[T]) Pop

func (this *Ring29[T]) Pop() (T, bool)

func (*Ring29[T]) Push

func (this *Ring29[T]) Push(element T) bool

func (*Ring29[T]) Remove

func (this *Ring29[T]) Remove(T) bool

type Ring3

type Ring3[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring3[T]) Cap

func (this *Ring3[T]) Cap() int

func (*Ring3[T]) Len

func (this *Ring3[T]) Len() int

func (*Ring3[T]) Peek

func (this *Ring3[T]) Peek() (T, bool)

func (*Ring3[T]) Pop

func (this *Ring3[T]) Pop() (T, bool)

func (*Ring3[T]) Push

func (this *Ring3[T]) Push(element T) bool

func (*Ring3[T]) Remove

func (this *Ring3[T]) Remove(T) bool

type Ring30

type Ring30[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring30[T]) Cap

func (this *Ring30[T]) Cap() int

func (*Ring30[T]) Len

func (this *Ring30[T]) Len() int

func (*Ring30[T]) Peek

func (this *Ring30[T]) Peek() (T, bool)

func (*Ring30[T]) Pop

func (this *Ring30[T]) Pop() (T, bool)

func (*Ring30[T]) Push

func (this *Ring30[T]) Push(element T) bool

func (*Ring30[T]) Remove

func (this *Ring30[T]) Remove(T) bool

type Ring31

type Ring31[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring31[T]) Cap

func (this *Ring31[T]) Cap() int

func (*Ring31[T]) Len

func (this *Ring31[T]) Len() int

func (*Ring31[T]) Peek

func (this *Ring31[T]) Peek() (T, bool)

func (*Ring31[T]) Pop

func (this *Ring31[T]) Pop() (T, bool)

func (*Ring31[T]) Push

func (this *Ring31[T]) Push(element T) bool

func (*Ring31[T]) Remove

func (this *Ring31[T]) Remove(T) bool

type Ring32

type Ring32[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring32[T]) Cap

func (this *Ring32[T]) Cap() int

func (*Ring32[T]) Len

func (this *Ring32[T]) Len() int

func (*Ring32[T]) Peek

func (this *Ring32[T]) Peek() (T, bool)

func (*Ring32[T]) Pop

func (this *Ring32[T]) Pop() (T, bool)

func (*Ring32[T]) Push

func (this *Ring32[T]) Push(element T) bool

func (*Ring32[T]) Remove

func (this *Ring32[T]) Remove(T) bool

type Ring33

type Ring33[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring33[T]) Cap

func (this *Ring33[T]) Cap() int

func (*Ring33[T]) Len

func (this *Ring33[T]) Len() int

func (*Ring33[T]) Peek

func (this *Ring33[T]) Peek() (T, bool)

func (*Ring33[T]) Pop

func (this *Ring33[T]) Pop() (T, bool)

func (*Ring33[T]) Push

func (this *Ring33[T]) Push(element T) bool

func (*Ring33[T]) Remove

func (this *Ring33[T]) Remove(T) bool

type Ring34

type Ring34[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring34[T]) Cap

func (this *Ring34[T]) Cap() int

func (*Ring34[T]) Len

func (this *Ring34[T]) Len() int

func (*Ring34[T]) Peek

func (this *Ring34[T]) Peek() (T, bool)

func (*Ring34[T]) Pop

func (this *Ring34[T]) Pop() (T, bool)

func (*Ring34[T]) Push

func (this *Ring34[T]) Push(element T) bool

func (*Ring34[T]) Remove

func (this *Ring34[T]) Remove(T) bool

type Ring4

type Ring4[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring4[T]) Cap

func (this *Ring4[T]) Cap() int

func (*Ring4[T]) Len

func (this *Ring4[T]) Len() int

func (*Ring4[T]) Peek

func (this *Ring4[T]) Peek() (T, bool)

func (*Ring4[T]) Pop

func (this *Ring4[T]) Pop() (T, bool)

func (*Ring4[T]) Push

func (this *Ring4[T]) Push(element T) bool

func (*Ring4[T]) Remove

func (this *Ring4[T]) Remove(T) bool

type Ring5

type Ring5[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring5[T]) Cap

func (this *Ring5[T]) Cap() int

func (*Ring5[T]) Len

func (this *Ring5[T]) Len() int

func (*Ring5[T]) Peek

func (this *Ring5[T]) Peek() (T, bool)

func (*Ring5[T]) Pop

func (this *Ring5[T]) Pop() (T, bool)

func (*Ring5[T]) Push

func (this *Ring5[T]) Push(element T) bool

func (*Ring5[T]) Remove

func (this *Ring5[T]) Remove(T) bool

type Ring6

type Ring6[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring6[T]) Cap

func (this *Ring6[T]) Cap() int

func (*Ring6[T]) Len

func (this *Ring6[T]) Len() int

func (*Ring6[T]) Peek

func (this *Ring6[T]) Peek() (T, bool)

func (*Ring6[T]) Pop

func (this *Ring6[T]) Pop() (T, bool)

func (*Ring6[T]) Push

func (this *Ring6[T]) Push(element T) bool

func (*Ring6[T]) Remove

func (this *Ring6[T]) Remove(T) bool

type Ring7

type Ring7[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring7[T]) Cap

func (this *Ring7[T]) Cap() int

func (*Ring7[T]) Len

func (this *Ring7[T]) Len() int

func (*Ring7[T]) Peek

func (this *Ring7[T]) Peek() (T, bool)

func (*Ring7[T]) Pop

func (this *Ring7[T]) Pop() (T, bool)

func (*Ring7[T]) Push

func (this *Ring7[T]) Push(element T) bool

func (*Ring7[T]) Remove

func (this *Ring7[T]) Remove(T) bool

type Ring8

type Ring8[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring8[T]) Cap

func (this *Ring8[T]) Cap() int

func (*Ring8[T]) Len

func (this *Ring8[T]) Len() int

func (*Ring8[T]) Peek

func (this *Ring8[T]) Peek() (T, bool)

func (*Ring8[T]) Pop

func (this *Ring8[T]) Pop() (T, bool)

func (*Ring8[T]) Push

func (this *Ring8[T]) Push(element T) bool

func (*Ring8[T]) Remove

func (this *Ring8[T]) Remove(T) bool

type Ring9

type Ring9[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func (*Ring9[T]) Cap

func (this *Ring9[T]) Cap() int

func (*Ring9[T]) Len

func (this *Ring9[T]) Len() int

func (*Ring9[T]) Peek

func (this *Ring9[T]) Peek() (T, bool)

func (*Ring9[T]) Pop

func (this *Ring9[T]) Pop() (T, bool)

func (*Ring9[T]) Push

func (this *Ring9[T]) Push(element T) bool

func (*Ring9[T]) Remove

func (this *Ring9[T]) Remove(T) bool

type SortedSet10

type SortedSet10[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet10

func NewSortedSet10[T common.Comparable[T]]() *SortedSet10[T]

func (*SortedSet10[T]) All

func (this *SortedSet10[T]) All() iter.Seq[T]

func (*SortedSet10[T]) Delete

func (this *SortedSet10[T]) Delete(element T) error

func (*SortedSet10[T]) ForEach

func (this *SortedSet10[T]) ForEach(yield func(T) bool)

func (*SortedSet10[T]) Get

func (this *SortedSet10[T]) Get(element T) (T, error)

func (*SortedSet10[T]) Put

func (this *SortedSet10[T]) Put(element T) error

type SortedSet11

type SortedSet11[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet11

func NewSortedSet11[T common.Comparable[T]]() *SortedSet11[T]

func (*SortedSet11[T]) All

func (this *SortedSet11[T]) All() iter.Seq[T]

func (*SortedSet11[T]) Delete

func (this *SortedSet11[T]) Delete(element T) error

func (*SortedSet11[T]) ForEach

func (this *SortedSet11[T]) ForEach(yield func(T) bool)

func (*SortedSet11[T]) Get

func (this *SortedSet11[T]) Get(element T) (T, error)

func (*SortedSet11[T]) Put

func (this *SortedSet11[T]) Put(element T) error

type SortedSet12

type SortedSet12[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet12

func NewSortedSet12[T common.Comparable[T]]() *SortedSet12[T]

func (*SortedSet12[T]) All

func (this *SortedSet12[T]) All() iter.Seq[T]

func (*SortedSet12[T]) Delete

func (this *SortedSet12[T]) Delete(element T) error

func (*SortedSet12[T]) ForEach

func (this *SortedSet12[T]) ForEach(yield func(T) bool)

func (*SortedSet12[T]) Get

func (this *SortedSet12[T]) Get(element T) (T, error)

func (*SortedSet12[T]) Put

func (this *SortedSet12[T]) Put(element T) error

type SortedSet13

type SortedSet13[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet13

func NewSortedSet13[T common.Comparable[T]]() *SortedSet13[T]

func (*SortedSet13[T]) All

func (this *SortedSet13[T]) All() iter.Seq[T]

func (*SortedSet13[T]) Delete

func (this *SortedSet13[T]) Delete(element T) error

func (*SortedSet13[T]) ForEach

func (this *SortedSet13[T]) ForEach(yield func(T) bool)

func (*SortedSet13[T]) Get

func (this *SortedSet13[T]) Get(element T) (T, error)

func (*SortedSet13[T]) Put

func (this *SortedSet13[T]) Put(element T) error

type SortedSet14

type SortedSet14[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet14

func NewSortedSet14[T common.Comparable[T]]() *SortedSet14[T]

func (*SortedSet14[T]) All

func (this *SortedSet14[T]) All() iter.Seq[T]

func (*SortedSet14[T]) Delete

func (this *SortedSet14[T]) Delete(element T) error

func (*SortedSet14[T]) ForEach

func (this *SortedSet14[T]) ForEach(yield func(T) bool)

func (*SortedSet14[T]) Get

func (this *SortedSet14[T]) Get(element T) (T, error)

func (*SortedSet14[T]) Put

func (this *SortedSet14[T]) Put(element T) error

type SortedSet15

type SortedSet15[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet15

func NewSortedSet15[T common.Comparable[T]]() *SortedSet15[T]

func (*SortedSet15[T]) All

func (this *SortedSet15[T]) All() iter.Seq[T]

func (*SortedSet15[T]) Delete

func (this *SortedSet15[T]) Delete(element T) error

func (*SortedSet15[T]) ForEach

func (this *SortedSet15[T]) ForEach(yield func(T) bool)

func (*SortedSet15[T]) Get

func (this *SortedSet15[T]) Get(element T) (T, error)

func (*SortedSet15[T]) Put

func (this *SortedSet15[T]) Put(element T) error

type SortedSet16

type SortedSet16[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet16

func NewSortedSet16[T common.Comparable[T]]() *SortedSet16[T]

func (*SortedSet16[T]) All

func (this *SortedSet16[T]) All() iter.Seq[T]

func (*SortedSet16[T]) Delete

func (this *SortedSet16[T]) Delete(element T) error

func (*SortedSet16[T]) ForEach

func (this *SortedSet16[T]) ForEach(yield func(T) bool)

func (*SortedSet16[T]) Get

func (this *SortedSet16[T]) Get(element T) (T, error)

func (*SortedSet16[T]) Put

func (this *SortedSet16[T]) Put(element T) error

type SortedSet17

type SortedSet17[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet17

func NewSortedSet17[T common.Comparable[T]]() *SortedSet17[T]

func (*SortedSet17[T]) All

func (this *SortedSet17[T]) All() iter.Seq[T]

func (*SortedSet17[T]) Delete

func (this *SortedSet17[T]) Delete(element T) error

func (*SortedSet17[T]) ForEach

func (this *SortedSet17[T]) ForEach(yield func(T) bool)

func (*SortedSet17[T]) Get

func (this *SortedSet17[T]) Get(element T) (T, error)

func (*SortedSet17[T]) Put

func (this *SortedSet17[T]) Put(element T) error

type SortedSet18

type SortedSet18[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet18

func NewSortedSet18[T common.Comparable[T]]() *SortedSet18[T]

func (*SortedSet18[T]) All

func (this *SortedSet18[T]) All() iter.Seq[T]

func (*SortedSet18[T]) Delete

func (this *SortedSet18[T]) Delete(element T) error

func (*SortedSet18[T]) ForEach

func (this *SortedSet18[T]) ForEach(yield func(T) bool)

func (*SortedSet18[T]) Get

func (this *SortedSet18[T]) Get(element T) (T, error)

func (*SortedSet18[T]) Put

func (this *SortedSet18[T]) Put(element T) error

type SortedSet19

type SortedSet19[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet19

func NewSortedSet19[T common.Comparable[T]]() *SortedSet19[T]

func (*SortedSet19[T]) All

func (this *SortedSet19[T]) All() iter.Seq[T]

func (*SortedSet19[T]) Delete

func (this *SortedSet19[T]) Delete(element T) error

func (*SortedSet19[T]) ForEach

func (this *SortedSet19[T]) ForEach(yield func(T) bool)

func (*SortedSet19[T]) Get

func (this *SortedSet19[T]) Get(element T) (T, error)

func (*SortedSet19[T]) Put

func (this *SortedSet19[T]) Put(element T) error

type SortedSet20

type SortedSet20[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet20

func NewSortedSet20[T common.Comparable[T]]() *SortedSet20[T]

func (*SortedSet20[T]) All

func (this *SortedSet20[T]) All() iter.Seq[T]

func (*SortedSet20[T]) Delete

func (this *SortedSet20[T]) Delete(element T) error

func (*SortedSet20[T]) ForEach

func (this *SortedSet20[T]) ForEach(yield func(T) bool)

func (*SortedSet20[T]) Get

func (this *SortedSet20[T]) Get(element T) (T, error)

func (*SortedSet20[T]) Put

func (this *SortedSet20[T]) Put(element T) error

type SortedSet21

type SortedSet21[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet21

func NewSortedSet21[T common.Comparable[T]]() *SortedSet21[T]

func (*SortedSet21[T]) All

func (this *SortedSet21[T]) All() iter.Seq[T]

func (*SortedSet21[T]) Delete

func (this *SortedSet21[T]) Delete(element T) error

func (*SortedSet21[T]) ForEach

func (this *SortedSet21[T]) ForEach(yield func(T) bool)

func (*SortedSet21[T]) Get

func (this *SortedSet21[T]) Get(element T) (T, error)

func (*SortedSet21[T]) Put

func (this *SortedSet21[T]) Put(element T) error

type SortedSet22

type SortedSet22[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet22

func NewSortedSet22[T common.Comparable[T]]() *SortedSet22[T]

func (*SortedSet22[T]) All

func (this *SortedSet22[T]) All() iter.Seq[T]

func (*SortedSet22[T]) Delete

func (this *SortedSet22[T]) Delete(element T) error

func (*SortedSet22[T]) ForEach

func (this *SortedSet22[T]) ForEach(yield func(T) bool)

func (*SortedSet22[T]) Get

func (this *SortedSet22[T]) Get(element T) (T, error)

func (*SortedSet22[T]) Put

func (this *SortedSet22[T]) Put(element T) error

type SortedSet23

type SortedSet23[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet23

func NewSortedSet23[T common.Comparable[T]]() *SortedSet23[T]

func (*SortedSet23[T]) All

func (this *SortedSet23[T]) All() iter.Seq[T]

func (*SortedSet23[T]) Delete

func (this *SortedSet23[T]) Delete(element T) error

func (*SortedSet23[T]) ForEach

func (this *SortedSet23[T]) ForEach(yield func(T) bool)

func (*SortedSet23[T]) Get

func (this *SortedSet23[T]) Get(element T) (T, error)

func (*SortedSet23[T]) Put

func (this *SortedSet23[T]) Put(element T) error

type SortedSet24

type SortedSet24[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet24

func NewSortedSet24[T common.Comparable[T]]() *SortedSet24[T]

func (*SortedSet24[T]) All

func (this *SortedSet24[T]) All() iter.Seq[T]

func (*SortedSet24[T]) Delete

func (this *SortedSet24[T]) Delete(element T) error

func (*SortedSet24[T]) ForEach

func (this *SortedSet24[T]) ForEach(yield func(T) bool)

func (*SortedSet24[T]) Get

func (this *SortedSet24[T]) Get(element T) (T, error)

func (*SortedSet24[T]) Put

func (this *SortedSet24[T]) Put(element T) error

type SortedSet25

type SortedSet25[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet25

func NewSortedSet25[T common.Comparable[T]]() *SortedSet25[T]

func (*SortedSet25[T]) All

func (this *SortedSet25[T]) All() iter.Seq[T]

func (*SortedSet25[T]) Delete

func (this *SortedSet25[T]) Delete(element T) error

func (*SortedSet25[T]) ForEach

func (this *SortedSet25[T]) ForEach(yield func(T) bool)

func (*SortedSet25[T]) Get

func (this *SortedSet25[T]) Get(element T) (T, error)

func (*SortedSet25[T]) Put

func (this *SortedSet25[T]) Put(element T) error

type SortedSet26

type SortedSet26[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet26

func NewSortedSet26[T common.Comparable[T]]() *SortedSet26[T]

func (*SortedSet26[T]) All

func (this *SortedSet26[T]) All() iter.Seq[T]

func (*SortedSet26[T]) Delete

func (this *SortedSet26[T]) Delete(element T) error

func (*SortedSet26[T]) ForEach

func (this *SortedSet26[T]) ForEach(yield func(T) bool)

func (*SortedSet26[T]) Get

func (this *SortedSet26[T]) Get(element T) (T, error)

func (*SortedSet26[T]) Put

func (this *SortedSet26[T]) Put(element T) error

type SortedSet27

type SortedSet27[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet27

func NewSortedSet27[T common.Comparable[T]]() *SortedSet27[T]

func (*SortedSet27[T]) All

func (this *SortedSet27[T]) All() iter.Seq[T]

func (*SortedSet27[T]) Delete

func (this *SortedSet27[T]) Delete(element T) error

func (*SortedSet27[T]) ForEach

func (this *SortedSet27[T]) ForEach(yield func(T) bool)

func (*SortedSet27[T]) Get

func (this *SortedSet27[T]) Get(element T) (T, error)

func (*SortedSet27[T]) Put

func (this *SortedSet27[T]) Put(element T) error

type SortedSet28

type SortedSet28[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet28

func NewSortedSet28[T common.Comparable[T]]() *SortedSet28[T]

func (*SortedSet28[T]) All

func (this *SortedSet28[T]) All() iter.Seq[T]

func (*SortedSet28[T]) Delete

func (this *SortedSet28[T]) Delete(element T) error

func (*SortedSet28[T]) ForEach

func (this *SortedSet28[T]) ForEach(yield func(T) bool)

func (*SortedSet28[T]) Get

func (this *SortedSet28[T]) Get(element T) (T, error)

func (*SortedSet28[T]) Put

func (this *SortedSet28[T]) Put(element T) error

type SortedSet29

type SortedSet29[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet29

func NewSortedSet29[T common.Comparable[T]]() *SortedSet29[T]

func (*SortedSet29[T]) All

func (this *SortedSet29[T]) All() iter.Seq[T]

func (*SortedSet29[T]) Delete

func (this *SortedSet29[T]) Delete(element T) error

func (*SortedSet29[T]) ForEach

func (this *SortedSet29[T]) ForEach(yield func(T) bool)

func (*SortedSet29[T]) Get

func (this *SortedSet29[T]) Get(element T) (T, error)

func (*SortedSet29[T]) Put

func (this *SortedSet29[T]) Put(element T) error

type SortedSet30

type SortedSet30[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet30

func NewSortedSet30[T common.Comparable[T]]() *SortedSet30[T]

func (*SortedSet30[T]) All

func (this *SortedSet30[T]) All() iter.Seq[T]

func (*SortedSet30[T]) Delete

func (this *SortedSet30[T]) Delete(element T) error

func (*SortedSet30[T]) ForEach

func (this *SortedSet30[T]) ForEach(yield func(T) bool)

func (*SortedSet30[T]) Get

func (this *SortedSet30[T]) Get(element T) (T, error)

func (*SortedSet30[T]) Put

func (this *SortedSet30[T]) Put(element T) error

type SortedSet31

type SortedSet31[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet31

func NewSortedSet31[T common.Comparable[T]]() *SortedSet31[T]

func (*SortedSet31[T]) All

func (this *SortedSet31[T]) All() iter.Seq[T]

func (*SortedSet31[T]) Delete

func (this *SortedSet31[T]) Delete(element T) error

func (*SortedSet31[T]) ForEach

func (this *SortedSet31[T]) ForEach(yield func(T) bool)

func (*SortedSet31[T]) Get

func (this *SortedSet31[T]) Get(element T) (T, error)

func (*SortedSet31[T]) Put

func (this *SortedSet31[T]) Put(element T) error

type SortedSet32

type SortedSet32[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet32

func NewSortedSet32[T common.Comparable[T]]() *SortedSet32[T]

func (*SortedSet32[T]) All

func (this *SortedSet32[T]) All() iter.Seq[T]

func (*SortedSet32[T]) Delete

func (this *SortedSet32[T]) Delete(element T) error

func (*SortedSet32[T]) ForEach

func (this *SortedSet32[T]) ForEach(yield func(T) bool)

func (*SortedSet32[T]) Get

func (this *SortedSet32[T]) Get(element T) (T, error)

func (*SortedSet32[T]) Put

func (this *SortedSet32[T]) Put(element T) error

type SortedSet33

type SortedSet33[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet33

func NewSortedSet33[T common.Comparable[T]]() *SortedSet33[T]

func (*SortedSet33[T]) All

func (this *SortedSet33[T]) All() iter.Seq[T]

func (*SortedSet33[T]) Delete

func (this *SortedSet33[T]) Delete(element T) error

func (*SortedSet33[T]) ForEach

func (this *SortedSet33[T]) ForEach(yield func(T) bool)

func (*SortedSet33[T]) Get

func (this *SortedSet33[T]) Get(element T) (T, error)

func (*SortedSet33[T]) Put

func (this *SortedSet33[T]) Put(element T) error

type SortedSet34

type SortedSet34[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet34

func NewSortedSet34[T common.Comparable[T]]() *SortedSet34[T]

func (*SortedSet34[T]) All

func (this *SortedSet34[T]) All() iter.Seq[T]

func (*SortedSet34[T]) Delete

func (this *SortedSet34[T]) Delete(element T) error

func (*SortedSet34[T]) ForEach

func (this *SortedSet34[T]) ForEach(yield func(T) bool)

func (*SortedSet34[T]) Get

func (this *SortedSet34[T]) Get(element T) (T, error)

func (*SortedSet34[T]) Put

func (this *SortedSet34[T]) Put(element T) error

type SortedSet7

type SortedSet7[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet7

func NewSortedSet7[T common.Comparable[T]]() *SortedSet7[T]

func (*SortedSet7[T]) All

func (this *SortedSet7[T]) All() iter.Seq[T]

func (*SortedSet7[T]) Delete

func (this *SortedSet7[T]) Delete(element T) error

func (*SortedSet7[T]) ForEach

func (this *SortedSet7[T]) ForEach(yield func(T) bool)

func (*SortedSet7[T]) Get

func (this *SortedSet7[T]) Get(element T) (T, error)

func (*SortedSet7[T]) Put

func (this *SortedSet7[T]) Put(element T) error

type SortedSet8

type SortedSet8[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet8

func NewSortedSet8[T common.Comparable[T]]() *SortedSet8[T]

func (*SortedSet8[T]) All

func (this *SortedSet8[T]) All() iter.Seq[T]

func (*SortedSet8[T]) Delete

func (this *SortedSet8[T]) Delete(element T) error

func (*SortedSet8[T]) ForEach

func (this *SortedSet8[T]) ForEach(yield func(T) bool)

func (*SortedSet8[T]) Get

func (this *SortedSet8[T]) Get(element T) (T, error)

func (*SortedSet8[T]) Put

func (this *SortedSet8[T]) Put(element T) error

type SortedSet9

type SortedSet9[T common.Comparable[T]] struct {
	// contains filtered or unexported fields
}

func NewSortedSet9

func NewSortedSet9[T common.Comparable[T]]() *SortedSet9[T]

func (*SortedSet9[T]) All

func (this *SortedSet9[T]) All() iter.Seq[T]

func (*SortedSet9[T]) Delete

func (this *SortedSet9[T]) Delete(element T) error

func (*SortedSet9[T]) ForEach

func (this *SortedSet9[T]) ForEach(yield func(T) bool)

func (*SortedSet9[T]) Get

func (this *SortedSet9[T]) Get(element T) (T, error)

func (*SortedSet9[T]) Put

func (this *SortedSet9[T]) Put(element T) error

Directories

Path Synopsis
internal

Jump to

Keyboard shortcuts

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