package syncmap

import (

"sync"

)

// Map is a type safe sync.Map

type Map[K, V any] struct {

m sync.Map

}

func New[K, V any]() *Map[K, V] {

return &Map[K, V]{

m: sync.Map{},

}

}

// cast converts a value returned by the underlying sync.Map to T. The

// map returns a nil `any` for a missing key, and for a present key whose

// interface-typed value is nil. Neither can be type-asserted, so both

// become the zero T, which is nil for interface types.

func cast[T any](v any) T {

if v == nil {

var empty T

return empty

}

//nolint:forcetypeassert // Only K and V values ever enter the map.

return v.(T)

}

func (m *Map[K, V]) Store(k K, v V) {

m.m.Store(k, v)

}

func (m *Map[K, V]) Load(key K) (value V, ok bool) {

v, ok := m.m.Load(key)

return cast[V](v), ok

}

func (m *Map[K, V]) Delete(key K) {

m.m.Delete(key)

}

func (m *Map[K, V]) LoadAndDelete(key K) (actual V, loaded bool) {

act, loaded := m.m.LoadAndDelete(key)

return cast[V](act), loaded

}

// 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. As with sync.Map,

// actual is usable in both cases.

func (m *Map[K, V]) LoadOrStore(key K, value V) (actual V, loaded bool) {

act, loaded := m.m.LoadOrStore(key, value)

return cast[V](act), loaded

}

func (m *Map[K, V]) CompareAndSwap(key K, old V, newVal V) bool {

return m.m.CompareAndSwap(key, old, newVal)

}

func (m *Map[K, V]) CompareAndDelete(key K, old V) (deleted bool) {

return m.m.CompareAndDelete(key, old)

}

// Swap stores the given value for the key and returns the previous

// value if there was one. As with sync.Map, previous is the zero V when

// the key was absent.

func (m *Map[K, V]) Swap(key K, value V) (previous V, loaded bool) {

prev, loaded := m.m.Swap(key, value)

return cast[V](prev), loaded

}

func (m *Map[K, V]) Range(f func(key K, value V) bool) {

m.m.Range(func(key, value any) bool {

return f(cast[K](key), cast[V](value))

})

}