umap

type HashMultiMap ¶

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

HashMultiMap is a generic data structure that implements a multi-value map, where each key K can be associated with multiple values of type V.

This implementation allows duplicate values under the same key, as values are stored in a slice. This approach supports storing multiple identical items under the same key.

Usage: This map is particularly useful in scenarios where it is necessary to maintain a collection of items (including duplicates) for each key. It is optimized for scenarios where quick lookup, insertion, and deletion of items are required.

!IMPORTANT: This map is not safe for concurrent operations. Use ConcurrentMultiMap for concurrent operations. This map does not preserve the order of insertion and allows storing multiple identical items under the same key.

func NewHashMultiMap[K comparable, V any]() *HashMultiMap[K, V]

func (m *HashMultiMap[K, V]) Append(key K, values ...V) int

func (m *HashMultiMap[K, V]) Clear(key K) bool

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

func (m *HashMultiMap[K, V]) Iterator() iter.Seq2[K, []V]

func (m *HashMultiMap[K, V]) Remove(key K, predicate func(v V) bool) int

func (m *HashMultiMap[K, V]) Set(key K, values ...V) int

type MultiMap ¶

type MultiMap[K, V any] interface {
	// Get retrieves values associated with the key.
	// Returns a slice of values and a boolean indicating whether the key exists.
	// The slice may contain duplicate values.
	Get(key K) (value []V, ok bool)

	// Set replaces all values associated with the key with the provided values.
	// Returns the count of values that were already associated with the key and have been replaced.
	// This method clears any existing values and inserts the new ones, allowing duplicates among the new values.
	Set(key K, value ...V) int

	// Append adds values to the list of values associated with the key.
	// Returns the total count of values that match the appended ones, counting all occurrences including duplicates.
	// This method does not replace existing values but adds new ones, maintaining any existing duplicates.
	Append(key K, value ...V) int

	// Remove deletes values that match the predicate from the key's associated values.
	// Returns the number of deletions made, accounting for each instance of a value that matches the predicate.
	// Each matching value is checked and removed individually, including each duplicate.
	Remove(key K, predicate func(v V) bool) int

	// Clear removes all values associated with the key.
	// Returns true if there were any values associated with the key before clearing; otherwise, returns false.
	// This method effectively deletes all entries for the key, regardless of their count or duplication status.
	Clear(key K) bool

	// Iterator returns an iterator over all items
	Iterator() iter.Seq2[K, []V]
}

MultiMap defines an interface for a generic multimap. It allows multiple values, including duplicates, to be associated with a single key.

type ReflectiveMultiMap ¶

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

ReflectiveMultiMap is a multi-value map: key K -> []V. !IMPORTANT: This map is NOT safe for concurrent use. Wrap it with your own sync if needed.

func NewReflectiveMultiMap[K comparable, V comparable]() *ReflectiveMultiMap[K, V]

func (m *ReflectiveMultiMap[K, V]) Append(key K, values ...V) int

func (m *ReflectiveMultiMap[K, V]) Clear(key K) bool

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

func (m *ReflectiveMultiMap[K, V]) Iterator() iter.Seq2[K, []V]

func (m *ReflectiveMultiMap[K, V]) Remove(key K, predicate func(v V) bool) int

func (m *ReflectiveMultiMap[K, V]) Set(key K, values ...V) int

type UniqueHashMultiMap ¶

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

UniqueHashMultiMap is the same as UniqueMultiMap, but allows to specify custom hash function.

func NewUniqueHashMultiMap[K comparable, V comparable](hashMethod hash.Hash) *UniqueHashMultiMap[K, V]

func (m *UniqueHashMultiMap[K, V]) Append(key K, values ...V) int

func (m *UniqueHashMultiMap[K, V]) Clear(key K) bool

func (m *UniqueHashMultiMap[K, V]) Get(key K) (value []V, ok bool)

func (m *UniqueHashMultiMap[K, V]) Iterator() iter.Seq2[K, []V]

func (m *UniqueHashMultiMap[K, V]) Remove(key K, predicate func(v V) bool) int

func (m *UniqueHashMultiMap[K, V]) Set(key K, values ...V) int

type UniqueMultiMap ¶

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

UniqueMultiMap is a generic data structure that implements a multi-value map, where each key K can be associated with multiple unique values of type V.

This implementation ensures that there are no duplicate values under the same key, as values are stored in a secondary map where the hash code of each value serves as the key, and the value itself as the map value. This approach effectively prevents storing duplicate values under the same key.

Usage: This map is particularly useful in scenarios where it is necessary to maintain a collection of unique items (like a set) for each key, but unlike a traditional set, it organizes these items by their hash codes to speed up checks for duplicates, insertion, and deletion.

!IMPORTANT: This map is not safe for concurrent operations. Use ConcurrentMultiMap for concurrent operations. This map does not preserve the order of insertion and cannot store multiple identical items under the same key. It is optimized for scenarios where quick lookup, insertion, and deletion of items are required, and where each item can be uniquely identified by a hash code.

func NewUniqueMultiMap[K comparable, V comparable]() *UniqueMultiMap[K, V]

func (m *UniqueMultiMap[K, V]) Append(key K, values ...V) int

func (m *UniqueMultiMap[K, V]) Clear(key K) bool

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

func (m *UniqueMultiMap[K, V]) Iterator() iter.Seq2[K, []V]

func (m *UniqueMultiMap[K, V]) Remove(key K, predicate func(v V) bool) int

func (m *UniqueMultiMap[K, V]) Set(key K, values ...V) int