collection

Documentation

Index

• Constants
• func UUIDHashCode(input interface{}) uint32
• type ActionFunc
• type ConcurrentTxMap
  • func NewShardedConcurrentTxMap(initialCap int, hashfn HashFunc) ConcurrentTxMap
• type HashFunc
• type Iterator
  • func NewPagingIterator[V any](paginationFn PaginationFn[V]) Iterator[V]
  • func NewPagingIteratorWithToken[V any](paginationFn PaginationFn[V], pageToken []byte) Iterator[V]
• type MapEntry
• type MapIterator
• type PaginationFn
• type PagingIteratorImpl
  • func (iter *PagingIteratorImpl[V]) HasNext() bool
  • func (iter *PagingIteratorImpl[V]) Next() (V, error)
• type PredicateFunc
• type Queue
  • func NewPriorityQueue[T any](compareLess func(this T, other T) bool) Queue[T]
  • func NewPriorityQueueWithItems[T any](compareLess func(this T, other T) bool, items []T) Queue[T]
• type ShardedConcurrentTxMap
  • func (cmap *ShardedConcurrentTxMap) Contains(key interface{}) bool
  • func (cmap *ShardedConcurrentTxMap) Get(key interface{}) (interface{}, bool)
  • func (cmap *ShardedConcurrentTxMap) GetAndDo(key interface{}, fn ActionFunc) (interface{}, bool, error)
  • func (cmap *ShardedConcurrentTxMap) Iter() MapIterator
  • func (cmap *ShardedConcurrentTxMap) Len() int
  • func (cmap *ShardedConcurrentTxMap) Put(key interface{}, value interface{})
  • func (cmap *ShardedConcurrentTxMap) PutIfNotExist(key interface{}, value interface{}) bool
  • func (cmap *ShardedConcurrentTxMap) PutOrDo(key interface{}, value interface{}, fn ActionFunc) (interface{}, bool, error)
  • func (cmap *ShardedConcurrentTxMap) Remove(key interface{})
  • func (cmap *ShardedConcurrentTxMap) RemoveIf(key interface{}, fn PredicateFunc) bool

Constants

const (
	// UUIDStringLength is the length of an UUID represented as a hex string
	UUIDStringLength = 36 // xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
)

Functions

func UUIDHashCode

func UUIDHashCode(input interface{}) uint32

UUIDHashCode is a hash function for hashing string uuid if the uuid is malformed, then the hash function always returns 0 as the hash value

Types

type ActionFunc

type ActionFunc func(key interface{}, value interface{}) error

ActionFunc take a key and value, do calculation and return err

type ConcurrentTxMap

type ConcurrentTxMap interface {
	// Get returns the value for the given key
	Get(key interface{}) (interface{}, bool)
	// Contains returns true if the key exist and false otherwise
	Contains(key interface{}) bool
	// Put records the mapping from given key to value
	Put(key interface{}, value interface{})
	// PutIfNotExist records the key value mapping only
	// if the mapping does not already exist
	PutIfNotExist(key interface{}, value interface{}) bool
	// Remove deletes the key from the map
	Remove(key interface{})
	// GetAndDo returns the value corresponding to the key, and apply fn to key value before return value
	// return (value, value exist or not, error when evaluation fn)
	GetAndDo(key interface{}, fn ActionFunc) (interface{}, bool, error)
	// PutOrDo put the key value in the map, if key does not exists, otherwise, call fn with existing key and value
	// return (value, fn evaluated or not, error when evaluation fn)
	PutOrDo(key interface{}, value interface{}, fn ActionFunc) (interface{}, bool, error)
	// RemoveIf deletes the given key from the map if fn return true
	// return whether the key is removed or not
	RemoveIf(key interface{}, fn PredicateFunc) bool
	// Iter returns an iterator to the map
	Iter() MapIterator
	// Len returns the number of items in the map
	Len() int
}

ConcurrentTxMap is a generic interface for any implementation of a dictionary or a key value lookup table that is thread safe, and providing functionality to modify key / value pair inside within a transaction

func NewShardedConcurrentTxMap

func NewShardedConcurrentTxMap(initialCap int, hashfn HashFunc) ConcurrentTxMap

NewShardedConcurrentTxMap returns an instance of ShardedConcurrentMap

ShardedConcurrentMap is a thread safe map that maintains upto nShards number of maps internally to allow nShards writers to be acive at the same time. This map *does not* use re-entrant locks, so access to the map during iterator can cause a dead lock.

@param initialSz

The initial size for the map

@param hashfn

The hash function to use for sharding

type HashFunc

type HashFunc func(interface{}) uint32

HashFunc represents a hash function for string

type Iterator

type Iterator[V any] interface {
	// HasNext return whether this iterator has next value
	HasNext() bool
	// Next returns the next item and error
	Next() (V, error)
}

Iterator represents the interface for iterator

func NewPagingIterator

func NewPagingIterator[V any](
	paginationFn PaginationFn[V],
) Iterator[V]

NewPagingIterator create a new paging iterator

func NewPagingIteratorWithToken

func NewPagingIteratorWithToken[V any](
	paginationFn PaginationFn[V],
	pageToken []byte,
) Iterator[V]

NewPagingIteratorWithToken create a new paging iterator with initial token

type MapEntry

type MapEntry struct {
	// Key represents the key
	Key interface{}
	// Value represents the value
	Value interface{}
}

MapEntry represents a key-value entry within the map

type MapIterator

type MapIterator interface {
	// Close closes the iterator
	// and releases any allocated resources
	Close()
	// Entries returns a channel of MapEntry
	// objects that can be used in a range loop
	Entries() <-chan *MapEntry
}

MapIterator represents the interface for map iterators

type PaginationFn

type PaginationFn[V any] func(paginationToken []byte) ([]V, []byte, error)

PaginationFn is the function which get a page of results

type PagingIteratorImpl

type PagingIteratorImpl[V any] struct {
	// contains filtered or unexported fields
}

PagingIteratorImpl is the implementation of PagingIterator

func (*PagingIteratorImpl[V]) HasNext

func (iter *PagingIteratorImpl[V]) HasNext() bool

HasNext return whether has next item or err

func (*PagingIteratorImpl[V]) Next

func (iter *PagingIteratorImpl[V]) Next() (V, error)

Next return next item or err

type PredicateFunc

type PredicateFunc func(key interface{}, value interface{}) bool

PredicateFunc take a key and value, do calculation and return boolean

type Queue

type Queue[T any] interface {
	// Peek returns the first item of the queue
	Peek() T
	// Add push an item to the queue
	Add(item T)
	// Remove pop an item from the queue
	Remove() T
	// IsEmpty indicate if the queue is empty
	IsEmpty() bool
	// Len return the size of the queue
	Len() int
}

Queue is the interface for queue

func NewPriorityQueue

func NewPriorityQueue[T any](
	compareLess func(this T, other T) bool,
) Queue[T]

NewPriorityQueue create a new priority queue

func NewPriorityQueueWithItems

func NewPriorityQueueWithItems[T any](
	compareLess func(this T, other T) bool,
	items []T,
) Queue[T]

NewPriorityQueueWithItems creats a new priority queue with the provided list of items. PriorityQueue will take ownership of the passed in items, so caller should stop modifying it. The complexity is O(n) where n is the number of items

type ShardedConcurrentTxMap

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

ShardedConcurrentTxMap is an implementation of ConcurrentMap that internally uses multiple sharded maps to increase parallelism

func (*ShardedConcurrentTxMap) Contains

func (cmap *ShardedConcurrentTxMap) Contains(key interface{}) bool

Contains returns true if the key exist and false otherwise

func (*ShardedConcurrentTxMap) Get

func (cmap *ShardedConcurrentTxMap) Get(key interface{}) (interface{}, bool)

Get returns the value corresponding to the key, if it exist

func (*ShardedConcurrentTxMap) GetAndDo

func (cmap *ShardedConcurrentTxMap) GetAndDo(key interface{}, fn ActionFunc) (interface{}, bool, error)

GetAndDo returns the value corresponding to the key, and apply fn to key value before return value return (value, value exist or not, error when evaluation fn)

func (*ShardedConcurrentTxMap) Iter

func (cmap *ShardedConcurrentTxMap) Iter() MapIterator

Iter returns an iterator to the map. This map does not use re-entrant locks, so access or modification to the map during iteration can cause a dead lock.

func (*ShardedConcurrentTxMap) Len

func (cmap *ShardedConcurrentTxMap) Len() int

Len returns the number of items in the map

func (*ShardedConcurrentTxMap) Put

func (cmap *ShardedConcurrentTxMap) Put(key interface{}, value interface{})

Put records the given key value mapping. Overwrites previous values

func (*ShardedConcurrentTxMap) PutIfNotExist

func (cmap *ShardedConcurrentTxMap) PutIfNotExist(key interface{}, value interface{}) bool

PutIfNotExist records the mapping, if there is no mapping for this key already Returns true if the mapping was recorded, false otherwise

func (*ShardedConcurrentTxMap) PutOrDo

func (cmap *ShardedConcurrentTxMap) PutOrDo(key interface{}, value interface{}, fn ActionFunc) (interface{}, bool, error)

PutOrDo put the key value in the map, if key does not exists, otherwise, call fn with existing key and value return (value, fn evaluated or not, error when evaluation fn)

func (*ShardedConcurrentTxMap) Remove

func (cmap *ShardedConcurrentTxMap) Remove(key interface{})

Remove deletes the given key from the map

func (*ShardedConcurrentTxMap) RemoveIf

func (cmap *ShardedConcurrentTxMap) RemoveIf(key interface{}, fn PredicateFunc) bool

RemoveIf deletes the given key from the map if fn return true