fastmap

package

Go to main page

Versions in this module

v1

v1.1.4

Jan 29, 2025

Changes in this version

type ComboKeyHashMap

+ func (m *ComboKeyHashMap[K, V]) GetByExactKeys(keys []K) (V, bool)

v1.1.3

Jan 29, 2025

Changes in this version

type AppendableMultiKeyHashMap

+ func (m *AppendableMultiKeyHashMap[K, V]) GetByExactKeys(keys []K) ([]V, bool)

+ func (m *AppendableMultiKeyHashMap[K, V]) GetByExactKeysAll(keyGroups [][]K) map[K][]V

+ type ComboKeyHashMap struct

+ func NewComboKeyHashMap[K comparable, V any]() *ComboKeyHashMap[K, V]

+ func (m *ComboKeyHashMap[K, V]) Get(keys []K) (V, bool)

+ func (m *ComboKeyHashMap[K, V]) GetByKeys(keys []K) []V

+ func (m *ComboKeyHashMap[K, V]) Put(keys []K, value V)

+ type KeyGroup []K

v1.1.2

Jan 29, 2025

Changes in this version

type AppendableMultiKeyHashMap

+ func (m *AppendableMultiKeyHashMap[K, V]) GetValuesByKeys(keys []K) map[K][]V

+ func (m *AppendableMultiKeyHashMap[K, V]) GetValuesByKeysWithPrimary(keys []K) map[K][]V

v1.1.1

Jan 27, 2025

Changes in this version

type AppendableHashMap

+ func (h *AppendableHashMap[K, V]) FilterValues(key K, predicate func(V) bool) bool

+ func (h *AppendableHashMap[K, V]) RemoveDuplicates(key K, equals func(a, b V) bool) bool

+ func (h *AppendableHashMap[K, V]) ReverseValues(key K) bool

+ func (h *AppendableHashMap[K, V]) SortValues(key K, less func(a, b V) bool) bool

+ func (h *AppendableHashMap[K, V]) SortValuesByField(key K, extractor func(V) any) bool

+ func (h *AppendableHashMap[K, V]) TransformValues(key K, transform func(V) V) bool

+ type AppendableMultiKeyHashMap struct

+ func NewAppendableMultiKeyHashMap[K comparable, V any]() *AppendableMultiKeyHashMap[K, V]

+ func (m *AppendableMultiKeyHashMap[K, V]) AppendValues(key K, values ...V) bool

+ func (m *AppendableMultiKeyHashMap[K, V]) AppendValuesWithKeys(keys []K, values ...V) bool

+ func (m *AppendableMultiKeyHashMap[K, V]) GetSlice(key K) ([]V, bool)

+ func (m *AppendableMultiKeyHashMap[K, V]) UpdateSlice(key K, newValues []V) bool

+ type MultiKeyHashMap struct

+ func NewMultiKeyHashMap[K comparable, V any]() *MultiKeyHashMap[K, V]

+ func (m *MultiKeyHashMap[K, V]) AddAlias(existingKey K, newAlias K) bool

+ func (m *MultiKeyHashMap[K, V]) Clear()

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

+ func (m *MultiKeyHashMap[K, V]) GetAllKeys(key K) []K

+ func (m *MultiKeyHashMap[K, V]) GetPrimaryKey(key K) (K, bool)

+ func (m *MultiKeyHashMap[K, V]) Put(keys []K, value V)

+ func (m *MultiKeyHashMap[K, V]) Remove(key K)

+ func (m *MultiKeyHashMap[K, V]) RemoveWithCascade(key K)

+ func (m *MultiKeyHashMap[K, V]) Size() int

type ThreadSafeAppendableHashMap

+ func (t *ThreadSafeAppendableHashMap[K, V]) FilterValues(key K, predicate func(V) bool) bool

+ func (t *ThreadSafeAppendableHashMap[K, V]) RemoveDuplicates(key K, equals func(a, b V) bool) bool

+ func (t *ThreadSafeAppendableHashMap[K, V]) ReverseValues(key K) bool

+ func (t *ThreadSafeAppendableHashMap[K, V]) SortValues(key K, less func(a, b V) bool) bool

+ func (t *ThreadSafeAppendableHashMap[K, V]) SortValuesByField(key K, extractor func(V) any) bool

+ func (t *ThreadSafeAppendableHashMap[K, V]) TransformValues(key K, transform func(V) V) bool

+ type ThreadSafeMultiKeyHashMap struct

+ func NewThreadSafeMultiKeyHashMap[K comparable, V any]() *ThreadSafeMultiKeyHashMap[K, V]

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) AddAlias(existingKey K, newAlias K) bool

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) Clear()

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) Get(key K) (V, bool)

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) GetAllKeys(key K) []K

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) GetPrimaryKey(key K) (K, bool)

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) Put(keys []K, value V)

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) Remove(key K)

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) RemoveWithCascade(key K)

+ func (t *ThreadSafeMultiKeyHashMap[K, V]) Size() int

v1.1.0

Jan 26, 2025

Changes in this version

+ type AppendableHashMap struct

+ func NewAppendableHashMap[K comparable, V any]() *AppendableHashMap[K, V]

+ func (h *AppendableHashMap[K, V]) AppendValues(key K, values ...V)

+ type ThreadSafeAppendableHashMap struct

+ func NewThreadSafeAppendableHashMap[K comparable, V any]() *ThreadSafeAppendableHashMap[K, V]

+ func (t *ThreadSafeAppendableHashMap[K, V]) AppendValues(key K, values ...V)

v1.0.0

Jan 26, 2025

Changes in this version

+ type FieldConfig struct

+ Handler func(data map[string]interface{}) *T

+ RowIndex *int

+ type HashMap struct

+ func FromMap[K comparable, V any](m map[K]V) *HashMap[K, V]

+ func NewHashMap[K comparable, V any]() *HashMap[K, V]

+ func (h *HashMap[K, V]) ApplyFieldConfig(key K, config FieldConfig[V], data map[string]interface{}) bool

+ func (h *HashMap[K, V]) Clear()

+ func (h *HashMap[K, V]) Contains(key K) bool

+ func (h *HashMap[K, V]) Filter(predicate func(K, V) bool) *HashMap[K, V]

+ func (h *HashMap[K, V]) ForEach(callback ValueCallback[K, V])

+ func (h *HashMap[K, V]) Get(key K) (V, bool)

+ func (h *HashMap[K, V]) HandleFieldConfigs(data []map[string]interface{}, configs map[K]FieldConfig[V], fieldKey K) []V

+ func (h *HashMap[K, V]) IsEmpty() bool

+ func (h *HashMap[K, V]) Keys() []K

+ func (h *HashMap[K, V]) Map(transform func(K, V) V) *HashMap[K, V]

+ func (h *HashMap[K, V]) ProcessFieldConfigs(configs map[K]FieldConfig[V], data []map[string]interface{}, ...)

+ func (h *HashMap[K, V]) Put(key K, value V)

+ func (h *HashMap[K, V]) PutAll(other *HashMap[K, V])

+ func (h *HashMap[K, V]) Remove(key K)

+ func (h *HashMap[K, V]) Size() int

+ func (h *HashMap[K, V]) ToMap() map[K]V

+ func (h *HashMap[K, V]) UpdateValue(id K, newValue V) bool

+ func (h *HashMap[K, V]) Values() []V

+ type ThreadSafeHashMap struct

+ func FromThreadSafeMap[K comparable, V any](m map[K]V) *ThreadSafeHashMap[K, V]

+ func NewThreadSafeHashMap[K comparable, V any]() *ThreadSafeHashMap[K, V]

+ func (t *ThreadSafeHashMap[K, V]) ApplyFieldConfig(key K, config FieldConfig[V], data map[string]interface{}) bool

+ func (t *ThreadSafeHashMap[K, V]) Clear()

+ func (t *ThreadSafeHashMap[K, V]) Contains(key K) bool

+ func (t *ThreadSafeHashMap[K, V]) Filter(predicate func(K, V) bool) *ThreadSafeHashMap[K, V]

+ func (t *ThreadSafeHashMap[K, V]) ForEach(callback ValueCallback[K, V])

+ func (t *ThreadSafeHashMap[K, V]) Get(key K) (V, bool)

+ func (t *ThreadSafeHashMap[K, V]) HandleFieldConfigs(data []map[string]interface{}, configs map[K]FieldConfig[V], fieldKey K) []V

+ func (t *ThreadSafeHashMap[K, V]) IsEmpty() bool

+ func (t *ThreadSafeHashMap[K, V]) Keys() []K

+ func (t *ThreadSafeHashMap[K, V]) Map(transform func(K, V) V) *ThreadSafeHashMap[K, V]

+ func (t *ThreadSafeHashMap[K, V]) ProcessFieldConfigs(configs map[K]FieldConfig[V], data []map[string]interface{}, ...)

+ func (t *ThreadSafeHashMap[K, V]) Put(key K, value V)

+ func (t *ThreadSafeHashMap[K, V]) PutAll(other *ThreadSafeHashMap[K, V])

+ func (t *ThreadSafeHashMap[K, V]) Remove(key K)

+ func (t *ThreadSafeHashMap[K, V]) Size() int

+ func (t *ThreadSafeHashMap[K, V]) ToMap() map[K]V

+ func (t *ThreadSafeHashMap[K, V]) UpdateValue(key K, newValue V) bool

+ func (t *ThreadSafeHashMap[K, V]) Values() []V

+ type ValueCallback func(key K, value V)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL