sortedmap

package module
v0.0.0-...-9db46b6 Latest Latest
Warning

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

 Go to latest Published: Jul 29, 2022 License: MIT Imports: 3 Imported by: 0

README

sapphi-red/sortedmap Go Reference CI

A simple sorted array (set, map) implementation with generics support.

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type NoLockSortedMap 

type NoLockSortedMap[K constraints.Ordered, V any] struct {
	// contains filtered or unexported fields
}

func NewNoLockSortedMap 

func NewNoLockSortedMap[K constraints.Ordered, V any](capacity int) *NoLockSortedMap[K, V]

func (*NoLockSortedMap[K, V]) Capacity 

func (s *NoLockSortedMap[K, V]) Capacity() int

func (*NoLockSortedMap[K, V]) Clear 

func (s *NoLockSortedMap[K, V]) Clear()

func (*NoLockSortedMap[K, V]) Contains 

func (s *NoLockSortedMap[K, V]) Contains(key K) bool

func (*NoLockSortedMap[K, V]) Delete 

func (s *NoLockSortedMap[K, V]) Delete(key K) int

func (*NoLockSortedMap[K, V]) DeleteAll 

func (s *NoLockSortedMap[K, V]) DeleteAll(keys []K)

func (*NoLockSortedMap[K, V]) DeleteAllOrdered 

func (s *NoLockSortedMap[K, V]) DeleteAllOrdered(keys []K)

func (*NoLockSortedMap[K, V]) DeleteWithAfterHint 

func (s *NoLockSortedMap[K, V]) DeleteWithAfterHint(key K, afterIndex int) int

func (*NoLockSortedMap[K, V]) ExtendCapacityTo 

func (s *NoLockSortedMap[K, V]) ExtendCapacityTo(newCap int)

func (*NoLockSortedMap[K, V]) GetByInclusiveRange 

func (s *NoLockSortedMap[K, V]) GetByInclusiveRange(startKey K, endKey K) []V

func (*NoLockSortedMap[K, V]) GetGreater 

func (s *NoLockSortedMap[K, V]) GetGreater(key K) []V

func (*NoLockSortedMap[K, V]) GetGreaterOrEqual 

func (s *NoLockSortedMap[K, V]) GetGreaterOrEqual(key K) []V

func (*NoLockSortedMap[K, V]) GetIndexOfGreater 

func (s *NoLockSortedMap[K, V]) GetIndexOfGreater(key K) int

func (*NoLockSortedMap[K, V]) GetIndexOfGreaterOrEqual 

func (s *NoLockSortedMap[K, V]) GetIndexOfGreaterOrEqual(key K) int

func (*NoLockSortedMap[K, V]) GetLess 

func (s *NoLockSortedMap[K, V]) GetLess(key K) []V

func (*NoLockSortedMap[K, V]) GetLessOrEqual 

func (s *NoLockSortedMap[K, V]) GetLessOrEqual(key K) []V

func (*NoLockSortedMap[K, V]) Insert 

func (s *NoLockSortedMap[K, V]) Insert(key K, value V) int

func (*NoLockSortedMap[K, V]) InsertAll 

func (s *NoLockSortedMap[K, V]) InsertAll(keys []K, values []V)

func (*NoLockSortedMap[K, V]) InsertAllByMap 

func (s *NoLockSortedMap[K, V]) InsertAllByMap(m map[K]V)

func (*NoLockSortedMap[K, V]) InsertAllOrdered 

func (s *NoLockSortedMap[K, V]) InsertAllOrdered(keys []K, values []V)

func (*NoLockSortedMap[K, V]) InsertWithAfterHint 

func (s *NoLockSortedMap[K, V]) InsertWithAfterHint(key K, value V, afterIndex int) int

func (*NoLockSortedMap[K, V]) Size 

func (s *NoLockSortedMap[K, V]) Size() int

type NoLockSortedMapCalc 

type NoLockSortedMapCalc[K constraints.Ordered, V any] struct {
	// contains filtered or unexported fields
}

func NewNoLockSortedMapCalc 

func NewNoLockSortedMapCalc[K constraints.Ordered, V any](capacity int, calcKey func(V) K) *NoLockSortedMapCalc[K, V]

func (*NoLockSortedMapCalc[K, V]) Capacity 

func (s *NoLockSortedMapCalc[K, V]) Capacity() int

func (*NoLockSortedMapCalc[K, V]) Clear 

func (s *NoLockSortedMapCalc[K, V]) Clear()

func (*NoLockSortedMapCalc[K, V]) Contains 

func (s *NoLockSortedMapCalc[K, V]) Contains(key K) bool

func (*NoLockSortedMapCalc[K, V]) Delete 

func (s *NoLockSortedMapCalc[K, V]) Delete(value V) int

func (*NoLockSortedMapCalc[K, V]) DeleteAll 

func (s *NoLockSortedMapCalc[K, V]) DeleteAll(values []V)

func (*NoLockSortedMapCalc[K, V]) DeleteAllOrdered 

func (s *NoLockSortedMapCalc[K, V]) DeleteAllOrdered(values []V)

func (*NoLockSortedMapCalc[K, V]) DeleteWithAfterHint 

func (s *NoLockSortedMapCalc[K, V]) DeleteWithAfterHint(value V, afterIndex int) int

func (*NoLockSortedMapCalc[K, V]) ExtendCapacityTo 

func (s *NoLockSortedMapCalc[K, V]) ExtendCapacityTo(newCap int)

func (*NoLockSortedMapCalc[K, V]) GetByInclusiveRange 

func (s *NoLockSortedMapCalc[K, V]) GetByInclusiveRange(startKey K, endKey K) []V

func (*NoLockSortedMapCalc[K, V]) GetGreater 

func (s *NoLockSortedMapCalc[K, V]) GetGreater(key K) []V

func (*NoLockSortedMapCalc[K, V]) GetGreaterOrEqual 

func (s *NoLockSortedMapCalc[K, V]) GetGreaterOrEqual(key K) []V

func (*NoLockSortedMapCalc[K, V]) GetIndexOfGreater 

func (s *NoLockSortedMapCalc[K, V]) GetIndexOfGreater(key K) int

func (*NoLockSortedMapCalc[K, V]) GetIndexOfGreaterOrEqual 

func (s *NoLockSortedMapCalc[K, V]) GetIndexOfGreaterOrEqual(key K) int

func (*NoLockSortedMapCalc[K, V]) GetLess 

func (s *NoLockSortedMapCalc[K, V]) GetLess(key K) []V

func (*NoLockSortedMapCalc[K, V]) GetLessOrEqual 

func (s *NoLockSortedMapCalc[K, V]) GetLessOrEqual(key K) []V

func (*NoLockSortedMapCalc[K, V]) Insert 

func (s *NoLockSortedMapCalc[K, V]) Insert(value V) int

func (*NoLockSortedMapCalc[K, V]) InsertAll 

func (s *NoLockSortedMapCalc[K, V]) InsertAll(values []V)

func (*NoLockSortedMapCalc[K, V]) InsertAllOrdered 

func (s *NoLockSortedMapCalc[K, V]) InsertAllOrdered(values []V)

func (*NoLockSortedMapCalc[K, V]) InsertWithAfterHint 

func (s *NoLockSortedMapCalc[K, V]) InsertWithAfterHint(value V, afterIndex int) int

func (*NoLockSortedMapCalc[K, V]) Size 

func (s *NoLockSortedMapCalc[K, V]) Size() int

type NoLockSortedSet 

type NoLockSortedSet[K constraints.Ordered] struct {
	// contains filtered or unexported fields
}

func NewNoLockSortedSet 

func NewNoLockSortedSet[K constraints.Ordered](capacity int) *NoLockSortedSet[K]

func (*NoLockSortedSet[K]) Capacity 

func (s *NoLockSortedSet[K]) Capacity() int

func (*NoLockSortedSet[K]) Clear 

func (s *NoLockSortedSet[K]) Clear()

func (*NoLockSortedSet[K]) Contains 

func (s *NoLockSortedSet[K]) Contains(value K) bool

func (*NoLockSortedSet[K]) Delete 

func (s *NoLockSortedSet[K]) Delete(value K) int

func (*NoLockSortedSet[K]) DeleteAll 

func (s *NoLockSortedSet[K]) DeleteAll(values []K)

func (*NoLockSortedSet[K]) DeleteAllOrdered 

func (s *NoLockSortedSet[K]) DeleteAllOrdered(values []K)

func (*NoLockSortedSet[K]) DeleteWithAfterHint 

func (s *NoLockSortedSet[K]) DeleteWithAfterHint(value K, afterIndex int) int

func (*NoLockSortedSet[K]) ExtendCapacityTo 

func (s *NoLockSortedSet[K]) ExtendCapacityTo(newCap int)

func (*NoLockSortedSet[K]) GetByInclusiveRange 

func (s *NoLockSortedSet[K]) GetByInclusiveRange(startValue K, endValue K) []K

func (*NoLockSortedSet[K]) GetGreater 

func (s *NoLockSortedSet[K]) GetGreater(value K) []K

func (*NoLockSortedSet[K]) GetGreaterOrEqual 

func (s *NoLockSortedSet[K]) GetGreaterOrEqual(value K) []K

func (*NoLockSortedSet[K]) GetIndexOfGreater 

func (s *NoLockSortedSet[K]) GetIndexOfGreater(value K) int

func (*NoLockSortedSet[K]) GetIndexOfGreaterOrEqual 

func (s *NoLockSortedSet[K]) GetIndexOfGreaterOrEqual(value K) int

func (*NoLockSortedSet[K]) GetLess 

func (s *NoLockSortedSet[K]) GetLess(value K) []K

func (*NoLockSortedSet[K]) GetLessOrEqual 

func (s *NoLockSortedSet[K]) GetLessOrEqual(value K) []K

func (*NoLockSortedSet[K]) Insert 

func (s *NoLockSortedSet[K]) Insert(value K) int

func (*NoLockSortedSet[K]) InsertAll 

func (s *NoLockSortedSet[K]) InsertAll(values []K)

func (*NoLockSortedSet[K]) InsertAllOrdered 

func (s *NoLockSortedSet[K]) InsertAllOrdered(values []K)

func (*NoLockSortedSet[K]) InsertWithAfterHint 

func (s *NoLockSortedSet[K]) InsertWithAfterHint(value K, afterIndex int) int

func (*NoLockSortedSet[K]) Size 

func (s *NoLockSortedSet[K]) Size() int

type SortedMap 

type SortedMap[K constraints.Ordered, V any] struct {
	// contains filtered or unexported fields
}

func NewSortedMap 

func NewSortedMap[K constraints.Ordered, V any](capacity int) *SortedMap[K, V]

func (*SortedMap[K, V]) Capacity 

func (s *SortedMap[K, V]) Capacity() int

func (*SortedMap[K, V]) Clear 

func (s *SortedMap[K, V]) Clear()

func (*SortedMap[K, V]) Contains 

func (s *SortedMap[K, V]) Contains(key K) bool

func (*SortedMap[K, V]) Delete 

func (s *SortedMap[K, V]) Delete(key K) int

func (*SortedMap[K, V]) DeleteAll 

func (s *SortedMap[K, V]) DeleteAll(keys []K)

func (*SortedMap[K, V]) DeleteAllOrdered 

func (s *SortedMap[K, V]) DeleteAllOrdered(keys []K)

func (*SortedMap[K, V]) DeleteWithAfterHint 

func (s *SortedMap[K, V]) DeleteWithAfterHint(value K, afterIndex int) int

func (*SortedMap[K, V]) ExtendCapacityTo 

func (s *SortedMap[K, V]) ExtendCapacityTo(newCap int)

func (*SortedMap[K, V]) GetByInclusiveRange 

func (s *SortedMap[K, V]) GetByInclusiveRange(startKey K, endKey K) []V

func (*SortedMap[K, V]) GetGreater 

func (s *SortedMap[K, V]) GetGreater(key K) []V

func (*SortedMap[K, V]) GetGreaterOrEqual 

func (s *SortedMap[K, V]) GetGreaterOrEqual(key K) []V

func (*SortedMap[K, V]) GetIndexOfGreater 

func (s *SortedMap[K, V]) GetIndexOfGreater(key K) int

func (*SortedMap[K, V]) GetIndexOfGreaterOrEqual 

func (s *SortedMap[K, V]) GetIndexOfGreaterOrEqual(key K) int

func (*SortedMap[K, V]) GetLess 

func (s *SortedMap[K, V]) GetLess(key K) []V

func (*SortedMap[K, V]) GetLessOrEqual 

func (s *SortedMap[K, V]) GetLessOrEqual(key K) []V

func (*SortedMap[K, V]) Insert 

func (s *SortedMap[K, V]) Insert(key K, value V) int

func (*SortedMap[K, V]) InsertAll 

func (s *SortedMap[K, V]) InsertAll(keys []K, values []V)

func (*SortedMap[K, V]) InsertAllByMap 

func (s *SortedMap[K, V]) InsertAllByMap(m map[K]V)

func (*SortedMap[K, V]) InsertAllOrdered 

func (s *SortedMap[K, V]) InsertAllOrdered(keys []K, values []V)

func (*SortedMap[K, V]) InsertWithAfterHint 

func (s *SortedMap[K, V]) InsertWithAfterHint(key K, value V, afterIndex int) int

func (*SortedMap[K, V]) Size 

func (s *SortedMap[K, V]) Size() int

type SortedMapCalc 

type SortedMapCalc[K constraints.Ordered, V any] struct {
	// contains filtered or unexported fields
}

func NewSortedMapCalc 

func NewSortedMapCalc[K constraints.Ordered, V any](capacity int, calcKey func(V) K) *SortedMapCalc[K, V]

func (*SortedMapCalc[K, V]) Capacity 

func (s *SortedMapCalc[K, V]) Capacity() int

func (*SortedMapCalc[K, V]) Clear 

func (s *SortedMapCalc[K, V]) Clear()

func (*SortedMapCalc[K, V]) Contains 

func (s *SortedMapCalc[K, V]) Contains(key K) bool

func (*SortedMapCalc[K, V]) Delete 

func (s *SortedMapCalc[K, V]) Delete(value V) int

func (*SortedMapCalc[K, V]) DeleteAll 

func (s *SortedMapCalc[K, V]) DeleteAll(values []V)

func (*SortedMapCalc[K, V]) DeleteAllOrdered 

func (s *SortedMapCalc[K, V]) DeleteAllOrdered(values []V)

func (*SortedMapCalc[K, V]) DeleteWithAfterHint 

func (s *SortedMapCalc[K, V]) DeleteWithAfterHint(value V, afterIndex int) int

func (*SortedMapCalc[K, V]) ExtendCapacityTo 

func (s *SortedMapCalc[K, V]) ExtendCapacityTo(newCap int)

func (*SortedMapCalc[K, V]) GetByInclusiveRange 

func (s *SortedMapCalc[K, V]) GetByInclusiveRange(startKey K, endKey K) []V

func (*SortedMapCalc[K, V]) GetGreater 

func (s *SortedMapCalc[K, V]) GetGreater(key K) []V

func (*SortedMapCalc[K, V]) GetGreaterOrEqual 

func (s *SortedMapCalc[K, V]) GetGreaterOrEqual(key K) []V

func (*SortedMapCalc[K, V]) GetIndexOfGreater 

func (s *SortedMapCalc[K, V]) GetIndexOfGreater(key K) int

func (*SortedMapCalc[K, V]) GetIndexOfGreaterOrEqual 

func (s *SortedMapCalc[K, V]) GetIndexOfGreaterOrEqual(key K) int

func (*SortedMapCalc[K, V]) GetLess 

func (s *SortedMapCalc[K, V]) GetLess(key K) []V

func (*SortedMapCalc[K, V]) GetLessOrEqual 

func (s *SortedMapCalc[K, V]) GetLessOrEqual(key K) []V

func (*SortedMapCalc[K, V]) Insert 

func (s *SortedMapCalc[K, V]) Insert(value V) int

func (*SortedMapCalc[K, V]) InsertAll 

func (s *SortedMapCalc[K, V]) InsertAll(values []V)

func (*SortedMapCalc[K, V]) InsertAllOrdered 

func (s *SortedMapCalc[K, V]) InsertAllOrdered(values []V)

func (*SortedMapCalc[K, V]) InsertWithAfterHint 

func (s *SortedMapCalc[K, V]) InsertWithAfterHint(value V, afterIndex int) int

func (*SortedMapCalc[K, V]) Size 

func (s *SortedMapCalc[K, V]) Size() int

type SortedSet 

type SortedSet[K constraints.Ordered] struct {
	// contains filtered or unexported fields
}

func NewSortedSet 

func NewSortedSet[K constraints.Ordered](capacity int) *SortedSet[K]

func (*SortedSet[K]) Capacity 

func (s *SortedSet[K]) Capacity() int

func (*SortedSet[K]) Clear 

func (s *SortedSet[K]) Clear()

func (*SortedSet[K]) Contains 

func (s *SortedSet[K]) Contains(value K) bool

func (*SortedSet[K]) Delete 

func (s *SortedSet[K]) Delete(value K) int

func (*SortedSet[K]) DeleteAll 

func (s *SortedSet[K]) DeleteAll(values []K)

func (*SortedSet[K]) DeleteAllOrdered 

func (s *SortedSet[K]) DeleteAllOrdered(values []K)

func (*SortedSet[K]) DeleteWithAfterHint 

func (s *SortedSet[K]) DeleteWithAfterHint(value K, afterIndex int) int

func (*SortedSet[K]) ExtendCapacityTo 

func (s *SortedSet[K]) ExtendCapacityTo(newCap int)

func (*SortedSet[K]) GetByInclusiveRange 

func (s *SortedSet[K]) GetByInclusiveRange(startValue K, endValue K) []K

func (*SortedSet[K]) GetGreater 

func (s *SortedSet[K]) GetGreater(value K) []K

func (*SortedSet[K]) GetGreaterOrEqual 

func (s *SortedSet[K]) GetGreaterOrEqual(value K) []K

func (*SortedSet[K]) GetIndexOfGreater 

func (s *SortedSet[K]) GetIndexOfGreater(value K) int

func (*SortedSet[K]) GetIndexOfGreaterOrEqual 

func (s *SortedSet[K]) GetIndexOfGreaterOrEqual(value K) int

func (*SortedSet[K]) GetLess 

func (s *SortedSet[K]) GetLess(value K) []K

func (*SortedSet[K]) GetLessOrEqual 

func (s *SortedSet[K]) GetLessOrEqual(value K) []K

func (*SortedSet[K]) Insert 

func (s *SortedSet[K]) Insert(value K) int

func (*SortedSet[K]) InsertAll 

func (s *SortedSet[K]) InsertAll(values []K)

func (*SortedSet[K]) InsertAllOrdered 

func (s *SortedSet[K]) InsertAllOrdered(values []K)

func (*SortedSet[K]) InsertWithAfterHint 

func (s *SortedSet[K]) InsertWithAfterHint(value K, afterIndex int) int

func (*SortedSet[K]) Size 

func (s *SortedSet[K]) Size() int

Source Files

View all Source files

Jump to

Keyboard shortcuts

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