hashmap

Documentation

Index

• type Consistenthash
  • func NewConsistenthash(replicas int) (m *Consistenthash)
  • func (t *Consistenthash) Add(keys ...int64)
  • func (t *Consistenthash) Del(key int64)
  • func (t *Consistenthash) Get(value int64) (node int64, ok bool)
  • func (t *Consistenthash) GetNextNodeStr(value string, step int) (nodes []int64, ok bool)
  • func (t *Consistenthash) GetStr(value string) (node int64, ok bool)
  • func (t *Consistenthash) Nodes() (_r []int64)
• type LimitHashMap
  • func NewLimitHashMap[...](capacity int) *LimitHashMap[K, V]
  • func NewLimitHashMapWithSegment[...](capacity, segmentNumber int) *LimitHashMap[K, V]
  • func (c *LimitHashMap[K, V]) Clear()
  • func (c *LimitHashMap[K, V]) Contains(key K) bool
  • func (c *LimitHashMap[K, V]) Del(key K)
  • func (c *LimitHashMap[K, V]) Get(key K) (r V, b bool)
  • func (c *LimitHashMap[K, V]) Len() int
  • func (c *LimitHashMap[K, V]) Put(key K, value V) (prev V, b bool)
• type LimitMap
  • func NewLimitMap[K comparable, V any](capacity int) *LimitMap[K, V]
  • func (mc *LimitMap[K, V]) Del(key K)
  • func (mc *LimitMap[K, V]) Get(key K) (value V, ok bool)
  • func (mc *LimitMap[K, V]) Len() int
  • func (mc *LimitMap[K, V]) Put(key K, value V) (prev V, b bool)
  • func (mc *LimitMap[K, V]) RemoveMulti(keys []K)
• type LinkedHashMap
  • func NewLinkedHashMap[K, V any](limit int64) *LinkedHashMap[K, V]
  • func (t *LinkedHashMap[K, V]) Back() (K, V, bool)
  • func (t *LinkedHashMap[K, V]) Clear()
  • func (t *LinkedHashMap[K, V]) Delete(k K)
  • func (t *LinkedHashMap[K, V]) Front() (K, V, bool)
  • func (t *LinkedHashMap[K, V]) Get(k K) (_r V, b bool)
  • func (t *LinkedHashMap[K, V]) Iterator(front bool) *LinkedHashMapIterator[K, V]
  • func (t *LinkedHashMap[K, V]) Len() int64
  • func (t *LinkedHashMap[K, V]) LoadOrStore(k K, v V) (actual V, loaded bool)
  • func (t *LinkedHashMap[K, V]) MoveToFront(k K)
  • func (t *LinkedHashMap[K, V]) Put(k K, v V)
• type LinkedHashMapIterator
  • func (it *LinkedHashMapIterator[K, V]) Next() (K, V, bool)
• type Map
  • func NewMap[K any, V any]() *Map[K, V]
  • func (t *Map[K, V]) Del(key K) (ok bool)
  • func (t *Map[K, V]) Get(key K) (v V, b bool)
  • func (t *Map[K, V]) Has(key K) (ok bool)
  • func (t *Map[K, V]) Put(key K, value V) (prev V, b bool)
  • func (t *Map[K, V]) Range(f func(k K, v V) bool)
• type MapL
  • func NewMapL[K any, V any]() *MapL[K, V]
  • func (t *MapL[K, V]) Del(key K) (ok bool)
  • func (t *MapL[K, V]) Get(key K) (_r V, b bool)
  • func (t *MapL[K, V]) Has(key K) (ok bool)
  • func (t *MapL[K, V]) Len() int64
  • func (t *MapL[K, V]) Put(key K, value V) (prev V, b bool)
  • func (t *MapL[K, V]) Range(f func(k K, v V) bool)
• type TreeMap
  • func NewTreeMap[K cmp.Ordered, V any](degree int) *TreeMap[K, V]
  • func (m *TreeMap[K, V]) Ascend(iter func(K, V) bool)
  • func (m *TreeMap[K, V]) Del(key K)
  • func (m *TreeMap[K, V]) Descend(iter func(K, V) bool)
  • func (m *TreeMap[K, V]) Get(key K) (V, bool)
  • func (m *TreeMap[K, V]) Put(key K, value V) (prev V, b bool)

Types

type Consistenthash

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

func NewConsistenthash

func NewConsistenthash(replicas int) (m *Consistenthash)

func (*Consistenthash) Add

func (t *Consistenthash) Add(keys ...int64)

func (*Consistenthash) Del

func (t *Consistenthash) Del(key int64)

func (*Consistenthash) Get

func (t *Consistenthash) Get(value int64) (node int64, ok bool)

func (*Consistenthash) GetNextNodeStr

func (t *Consistenthash) GetNextNodeStr(value string, step int) (nodes []int64, ok bool)

func (*Consistenthash) GetStr

func (t *Consistenthash) GetStr(value string) (node int64, ok bool)

func (*Consistenthash) Nodes

func (t *Consistenthash) Nodes() (_r []int64)

type LimitHashMap

type LimitHashMap[K int | int64 | int8 | int16 | int32 | uint | uint64 | uint8 | uint16 | uint32 | float64 | float32 | uintptr | string, V any] struct {
	// contains filtered or unexported fields
}

LimitHashMap is a capacity-limited hash map that supports different key types.

func NewLimitHashMap

func NewLimitHashMap[K int | int64 | int8 | int16 | int32 | uint | uint64 | uint8 | uint16 | uint32 | float64 | float32 | uintptr | string, V any](capacity int) *LimitHashMap[K, V]

NewLimitHashMap creates a new LimitHashMap with a specified capacity. Parameters:

capacity int - The total maximum capacity of the LimitHashMap.

Returns:

*LimitHashMap[K, V] - A new instance of a capacity-limited LimitHashMap.

func NewLimitHashMapWithSegment

func NewLimitHashMapWithSegment[K int | int64 | int8 | int16 | int32 | uint | uint64 | uint8 | uint16 | uint32 | float64 | float32 | uintptr | string, V any](capacity, segmentNumber int) *LimitHashMap[K, V]

NewLimitHashMapWithSegment creates a new LimitHashMap with a specified capacity and number of segments. Parameters:

capacity int - The total maximum capacity of the LimitHashMap.
segmentNumber int - The number of segments to divide the cache into.

Returns:

*LimitHashMap[K, V] - A new instance of a capacity-limited LimitHashMap divided into segments.

func (*LimitHashMap[K, V]) Clear

func (c *LimitHashMap[K, V]) Clear()

func (*LimitHashMap[K, V]) Contains

func (c *LimitHashMap[K, V]) Contains(key K) bool

func (*LimitHashMap[K, V]) Del

func (c *LimitHashMap[K, V]) Del(key K)

func (*LimitHashMap[K, V]) Get

func (c *LimitHashMap[K, V]) Get(key K) (r V, b bool)

func (*LimitHashMap[K, V]) Len

func (c *LimitHashMap[K, V]) Len() int

func (*LimitHashMap[K, V]) Put

func (c *LimitHashMap[K, V]) Put(key K, value V) (prev V, b bool)

type LimitMap

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

LimitMap represents a generic map with capacity limit

func NewLimitMap

func NewLimitMap[K comparable, V any](capacity int) *LimitMap[K, V]

NewLimitMap creates a new instance of LimitMap with the given capacity

func (*LimitMap[K, V]) Del

func (mc *LimitMap[K, V]) Del(key K)

Del deletes a key-value pair from the map

func (*LimitMap[K, V]) Get

func (mc *LimitMap[K, V]) Get(key K) (value V, ok bool)

Get retrieves a value from the cache by key

func (*LimitMap[K, V]) Len

func (mc *LimitMap[K, V]) Len() int

Len length of map

func (*LimitMap[K, V]) Put

func (mc *LimitMap[K, V]) Put(key K, value V) (prev V, b bool)

Put adds or updates a key-value pair in the map

func (*LimitMap[K, V]) RemoveMulti

func (mc *LimitMap[K, V]) RemoveMulti(keys []K)

RemoveMulti deletes multiple key-value pairs from the map

type LinkedHashMap

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

func NewLinkedHashMap

func NewLinkedHashMap[K, V any](limit int64) *LinkedHashMap[K, V]

func (*LinkedHashMap[K, V]) Back

func (t *LinkedHashMap[K, V]) Back() (K, V, bool)

func (*LinkedHashMap[K, V]) Clear

func (t *LinkedHashMap[K, V]) Clear()

func (*LinkedHashMap[K, V]) Delete

func (t *LinkedHashMap[K, V]) Delete(k K)

func (*LinkedHashMap[K, V]) Front

func (t *LinkedHashMap[K, V]) Front() (K, V, bool)

func (*LinkedHashMap[K, V]) Get

func (t *LinkedHashMap[K, V]) Get(k K) (_r V, b bool)

func (*LinkedHashMap[K, V]) Iterator

func (t *LinkedHashMap[K, V]) Iterator(front bool) *LinkedHashMapIterator[K, V]

func (*LinkedHashMap[K, V]) Len

func (t *LinkedHashMap[K, V]) Len() int64

func (*LinkedHashMap[K, V]) LoadOrStore

func (t *LinkedHashMap[K, V]) LoadOrStore(k K, v V) (actual V, loaded bool)

func (*LinkedHashMap[K, V]) MoveToFront

func (t *LinkedHashMap[K, V]) MoveToFront(k K)

func (*LinkedHashMap[K, V]) Put

func (t *LinkedHashMap[K, V]) Put(k K, v V)

type LinkedHashMapIterator

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

func (*LinkedHashMapIterator[K, V]) Next

func (it *LinkedHashMapIterator[K, V]) Next() (K, V, bool)

type Map

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

Map Define a generic synchronized map structure using sync.Map as the underlying data structure.

func NewMap

func NewMap[K any, V any]() *Map[K, V]

NewMap Create a new instance of a generic Map and return its pointer.

func (*Map[K, V]) Del

func (t *Map[K, V]) Del(key K) (ok bool)

func (*Map[K, V]) Get

func (t *Map[K, V]) Get(key K) (v V, b bool)

func (*Map[K, V]) Has

func (t *Map[K, V]) Has(key K) (ok bool)

func (*Map[K, V]) Put

func (t *Map[K, V]) Put(key K, value V) (prev V, b bool)

func (*Map[K, V]) Range

func (t *Map[K, V]) Range(f func(k K, v V) bool)

Range Iterate over all elements in the Map. For each element, call the provided function with the key and value. The iteration stops if the function returns false.

type MapL

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

MapL Define a generic synchronized map structure that also keeps track of its length. It uses sync.Map as the underlying data structure and an int64 variable to count the number of elements.

func NewMapL

func NewMapL[K any, V any]() *MapL[K, V]

NewMapL Create a new instance of a generic MapL and return its pointer. The initial length is set to 0.

func (*MapL[K, V]) Del

func (t *MapL[K, V]) Del(key K) (ok bool)

func (*MapL[K, V]) Get

func (t *MapL[K, V]) Get(key K) (_r V, b bool)

func (*MapL[K, V]) Has

func (t *MapL[K, V]) Has(key K) (ok bool)

func (*MapL[K, V]) Len

func (t *MapL[K, V]) Len() int64

func (*MapL[K, V]) Put

func (t *MapL[K, V]) Put(key K, value V) (prev V, b bool)

func (*MapL[K, V]) Range

func (t *MapL[K, V]) Range(f func(k K, v V) bool)

Range Iterate over all elements in the MapL. For each element, call the provided function with the key and value. The iteration stops if the function returns false.

type TreeMap

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

TreeMap Define the TreeMap structure which internally uses a B-tree for storing data with an RWMutex for concurrent access control.

func NewTreeMap

func NewTreeMap[K cmp.Ordered, V any](degree int) *TreeMap[K, V]

NewTreeMap Create a new instance of TreeMap with a specified degree for the underlying B-tree.

func (*TreeMap[K, V]) Ascend

func (m *TreeMap[K, V]) Ascend(iter func(K, V) bool)

Ascend Traverse all elements in ascending order based on their keys, executing the iterator function.

func (*TreeMap[K, V]) Del

func (m *TreeMap[K, V]) Del(key K)

Del Delete a key from the TreeMap.

func (*TreeMap[K, V]) Descend

func (m *TreeMap[K, V]) Descend(iter func(K, V) bool)

Descend Traverse all elements in descending order based on their keys, executing the iterator function.

func (*TreeMap[K, V]) Get

func (m *TreeMap[K, V]) Get(key K) (V, bool)

Get Retrieve a value from the TreeMap by its key, returning the value and a boolean indicating if the key was found.

func (*TreeMap[K, V]) Put

func (m *TreeMap[K, V]) Put(key K, value V) (prev V, b bool)

Put Insert or update a key-value pair in the TreeMap.