threadsafe

type CorePriorityQueue[T any] struct {
	// contains filtered or unexported fields
}

type Heap[T any] interface {
	// Push adds one or more items to the heap.
	Push(items ...T)

	// Pop removes and returns the top-priority item.
	// If the heap is empty, it returns ok == false and the zero value of T.
	Pop() (item T, ok bool)

	// Peek returns the top-priority item without removing it.
	// If the heap is empty, it returns ok == false and the zero value of T.
	Peek() (item T, ok bool)

	// Len returns the current number of items stored in the heap.
	Len() int

	// Clear removes all items from the heap.
	Clear()

	// Slice returns a copy of the current heap contents in internal heap order
	// (not sorted). The returned slice is safe to read but may be stale if
	// new items are added concurrently.
	Slice() []T

	// Range calls f sequentially for each item present in the heap in internal
	// heap order. If f returns false, Range stops the iteration early.
	Range(f func(item T) bool)

	// All returns an iterator over items in the heap in internal heap order (not sorted).
	// The iteration order is implementation-defined and not guaranteed to be priority-sorted.
	//
	// Example usage:
	//
	//	for item := range myHeap.All() {
	//	    fmt.Println(item)
	//	}
	All() iter.Seq[T]
}

type IndexedPriorityQueue[T any] struct {
	// contains filtered or unexported fields
}

type Map[K comparable, V any] interface {
	// Get retrieves the value for the given key.
	Get(key K) (value V, loaded bool)
	// Set stores a value for the given key.
	Set(key K, value V)
	// Delete removes the key from the map. If the key doesn't exist, Delete is a no-op.
	Delete(key K)
	// Len returns the number of items in the map.
	Len() int
	// Clear removes all items from the map.
	Clear()

	// CompareAndSwap executes the compare-and-swap operation for a key.
	CompareAndSwap(key K, oldValue, newValue V) bool
	// LoadAndDelete deletes the value for a key, returning the previous value if any.
	LoadAndDelete(key K) (previous V, loaded bool)
	// LoadOrStore returns the existing value for the key if present. Otherwise, it stores and
	// returns the given value. The loaded result is true if the value was loaded, false if stored.
	LoadOrStore(key K, value V) (previous V, loaded bool)
	// Swap swaps the value for a key and returns the previous value if any.
	Swap(key K, value V) (previous V, loaded bool)

	// GetAll returns all key-value pairs in the map.
	GetAll() map[K]V
	// GetMany retrieves select key-value pairs.
	GetMany(keys []K) map[K]V
	// SetMany sets multiple key-value pairs.
	SetMany(entries map[K]V)

	// Equals reports whether the logical content of this map and the other map is the same.
	// Requires an equal function since V is not of type comparable.
	Equals(other Map[K, V], equalFn func(a, b V) bool) bool

	// Range calls f sequentially for each key and value present in the map.
	// If f returns false, range stops the iteration.
	Range(f func(key K, value V) bool)

	// All returns an iterator over key-value pairs in the map.
	// The iteration order is not guaranteed to be consistent.
	// Note: for mutex backed maps this snapshots before iteration, making Range more performant.
	All() iter.Seq2[K, V]
	// Keys returns an iterator over keys in the map.
	// The iteration order is not guaranteed to be consistent.
	// Note: for mutex backed maps this snapshots before iteration, making Range more performant.
	Keys() iter.Seq[K]
	// Values returns an iterator over values in the map.
	// The iteration order is not guaranteed to be consistent.
	// Note: for mutex backed maps this snapshots before iteration, making Range more performant.
	Values() iter.Seq[V]
}

type MapDiff[K comparable, V any] struct {
	AddedOrModified map[K]V
	Removed         map[K]V
}

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

type MutexSlice[T any] struct {
	// contains filtered or unexported fields
}

type PriorityQueue[T any] interface {
	// Push inserts one or more items into the queue.
	Push(items ...T)

	// Pop removes and returns the minimum item per the comparator.
	// If empty, returns ok == false and the zero value of T.
	Pop() (item T, ok bool)

	// Peek returns the current minimum without removing it.
	// If empty, returns ok == false and the zero value of T.
	Peek() (item T, ok bool)

	// Len returns the number of items in the queue.
	Len() int

	// Clear removes all items from the queue.
	Clear()

	// Range iterates over items in arbitrary internal order. Returning false stops early.
	Range(f func(item T) bool)

	// All returns an iterator over items in the queue in internal heap order (not sorted).
	// The iteration order is implementation-defined and not guaranteed to be priority-sorted.
	//
	// Example usage:
	//
	//	for item := range myPQ.All() {
	//	    fmt.Println(item)
	//	}
	All() iter.Seq[T]
}

type PriorityQueueIndexed[T any] interface {
	PriorityQueue[T]

	// Fix re-establishes queue ordering after the item at index i may have changed.
	// Safe no-op if i is out of range.
	Fix(i int)

	// RemoveAt removes and returns the item at index i in the queue's internal array.
	// If i is out of range, returns zero value and ok == false.
	RemoveAt(i int) (item T, ok bool)

	// UpdateAt replaces the element at index i with x and restores queue invariants.
	// If i is out of range, it is a no-op and returns false.
	UpdateAt(i int, x T) bool
}

type Queue[T any] interface {
	// Push adds one or more items to the back of the queue.
	Push(items ...T)

	// Pop removes and returns the item at the front of the queue.
	// If the queue is empty, it returns ok == false and the zero value of T.
	Pop() (item T, ok bool)

	// Peek returns the item at the front of the queue without removing it.
	// If the queue is empty, it returns ok == false and the zero value of T.
	Peek() (item T, ok bool)

	// Len returns the current number of items stored in the queue.
	Len() int

	// Clear removes all items from the queue.
	Clear()

	// Slice returns a copy of the current queue contents from front to back.
	// The returned slice is safe to read but may be stale if new items are added
	// concurrently.
	Slice() []T

	// Range calls f sequentially for each item present in the queue from front
	// to back. If f returns false, Range stops the iteration early.
	Range(f func(item T) bool)

	// All returns an iterator over items in the queue from front to back.
	// The iteration order matches the queue order (FIFO).
	//
	// Example usage:
	//
	//	for item := range myQueue.All() {
	//	    fmt.Println(item)
	//	}
	All() iter.Seq[T]
}

type RWMutexHeap[T any] struct {
	// contains filtered or unexported fields
}

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

type RWMutexQueue[T any] struct {
	// contains filtered or unexported fields
}

type RWMutexSet[T comparable] struct {
	// contains filtered or unexported fields
}

type RWMutexSlice[T any] struct {
	// contains filtered or unexported fields
}

type Set[T comparable] interface {
	// Add stores an item in the set.
	Add(item T) (added bool)
	// Delete removes an item from the set. Returns true if the item was present and removed,
	// false if it was not in the set. If the item doesn't exist, Delete is a no-op.
	Delete(item T) (removed bool)
	// Has returns true if the item is in the set, otherwise false.
	Has(item T) bool
	// Len returns the number of items in the set.
	Len() int
	// Clear removes all items from the set.
	Clear()
	// Slice returns a copy of the set as a slice.
	Slice() []T
	// Range calls f sequentially for each item present in the set.
	// If f returns false, range stops the iteration.
	Range(f func(item T) bool)

	// All returns an iterator over all items in the set.
	// The iteration order is not guaranteed to be consistent.
	// Note: for mutex backed sets this snapshots before iteration, making Range more performant.
	All() iter.Seq[T]
}

type ShardedSlice[T any] struct {
	// contains filtered or unexported fields
}

type Slice[T any] interface {
	// Append appends an item to the buffer in a thread-safe way.
	Append(item ...T)
	// Len returns the current number of items in the buffer.
	Len() int
	// Peek returns a copy of the current buffer contents without clearing.
	// The returned slice is safe to read but may be stale if new items are added concurrently.
	Peek() []T
	// Flush atomically retrieves all items and clears the buffer.
	// Returns a slice with the previous contents.
	Flush() []T

	// All returns an iterator over all items in the slice in order.
	//
	// Example usage:
	//
	//	for item := range mySlice.All() {
	//	    fmt.Println(item)
	//	}
	All() iter.Seq[T]
}

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

type SyncMapSet[T comparable] struct {
	// contains filtered or unexported fields
}