remake safety slice

cache/reload/reload.go

@@ -23,7 +23,7 @@ func GetGlobeMutex() *sync.Mutex {
 	return mut
 }
 
-var reloadQueues = safety.NewSlice(make([]Queue, 0))
+var reloadQueues = safety.NewSlice[Queue]()
 
 var reloadQueueHookFns = safety.NewVar[[]func(queue Queue) (Queue, bool)](nil)
 

safety/rwmap.go

@@ -38,10 +38,14 @@ func (v *RWMap[K, V]) Del(keys ...K) {
 	}
 }
 
-func (v *RWMap[K, V]) Raw() map[K]V {
+func (v *RWMap[K, V]) Copy() map[K]V {
 	v.mux.RLock()
 	defer v.mux.RUnlock()
-	return v.m
+	var m = make(map[K]V)
+	for k, val := range v.m {
+		m[k] = val
+	}
+	return m
 }
 
 func (v *RWMap[K, V]) Len() int {

safety/slice.go

@@ -3,37 +3,37 @@ package safety
 import "sync"
 
 type Slice[T any] struct {
-	*Var[[]T]
+	Var []T
-	mu sync.Mutex
+	mu  sync.RWMutex
 }
 
-func NewSlice[T any](a []T) *Slice[T] {
+func NewSlice[T any](a ...[]T) *Slice[T] {
+	var s []T
+	if len(a) > 0 {
+		s = a[0]
+	}
 	return &Slice[T]{
-		NewVar(a),
+		s,
-		sync.Mutex{},
+		sync.RWMutex{},
 	}
 }
 
 func (r *Slice[T]) Append(t ...T) {
 	r.mu.Lock()
 	defer r.mu.Unlock()
-	ts := append(r.Var.Load(), t...)
+	r.Var = append(r.Var, t...)
-	r.Store(ts)
 }
 
-func (r *Slice[T]) Set(index int, val T) {
+func (r *Slice[T]) Store(a []T) {
-	v := r.Var.Load()
-	if index >= len(v) {
-		return
-	}
 	r.mu.Lock()
 	defer r.mu.Unlock()
-	v[index] = val
+	r.Var = a
 }
 
 func (r *Slice[T]) Load() (a []T) {
-	v := r.Var.Load()
+	r.mu.RLock()
-	a = make([]T, len(v))
+	defer r.mu.RUnlock()
-	copy(a, v)
+	a = make([]T, len(r.Var))
+	copy(a, r.Var)
 	return
 }

safety/slice_test.go

@@ -19,7 +19,7 @@ func TestSlice_Append(t *testing.T) {
 	tests := []testCase[int]{
 		{
 			name: "t1",
-			r:    *NewSlice([]int{}),
+			r:    *NewSlice[int](),
 			args: args[int]{number.Range(1, 10, 1)},
 		},
 	}

stream/stream.go

@@ -7,8 +7,7 @@ import (
 )
 
 func ParallelFilterAndMap[R, T any](a Stream[T], fn func(T) (R, bool), c int) Stream[R] {
-	var x []R
+	rr := safety.NewSlice[R]()
-	rr := safety.NewSlice(x)
 	a.ParallelForEach(func(t T) {
 		y, ok := fn(t)
 		if ok {
@@ -84,7 +83,7 @@ func (r Stream[T]) ParallelForEach(fn func(T), c int) {
 }
 
 func (r Stream[T]) ParallelFilterAndMap(fn func(T) (T, bool), c int) Stream[T] {
-	rr := safety.NewSlice([]T{})
+	rr := safety.NewSlice[T]()
 	r.ParallelForEach(func(t T) {
 		v, ok := fn(t)
 		if ok {