restructured the project to comply community guideline, for others check release note

internal/utils/functional/functional.go

@@ -0,0 +1,69 @@
+package functional
+
+import "sync"
+
+func ForEachKey[K comparable, V any](obj map[K]V, do func(K)) {
+	for k := range obj {
+		do(k)
+	}
+}
+
+func ForEachValue[K comparable, V any](obj map[K]V, do func(V)) {
+	for _, v := range obj {
+		do(v)
+	}
+}
+
+func ForEachKV[K comparable, V any](obj map[K]V, do func(K, V)) {
+	for k, v := range obj {
+		do(k, v)
+	}
+}
+
+func ParallelForEach[T any](obj []T, do func(T)) {
+	var wg sync.WaitGroup
+	wg.Add(len(obj))
+	for _, v := range obj {
+		go func(v T) {
+			do(v)
+			wg.Done()
+		}(v)
+	}
+	wg.Wait()
+}
+
+func ParallelForEachKey[K comparable, V any](obj map[K]V, do func(K)) {
+	var wg sync.WaitGroup
+	wg.Add(len(obj))
+	for k := range obj {
+		go func(k K) {
+			do(k)
+			wg.Done()
+		}(k)
+	}
+	wg.Wait()
+}
+
+func ParallelForEachValue[K comparable, V any](obj map[K]V, do func(V)) {
+	var wg sync.WaitGroup
+	wg.Add(len(obj))
+	for _, v := range obj {
+		go func(v V) {
+			do(v)
+			wg.Done()
+		}(v)
+	}
+	wg.Wait()
+}
+
+func ParallelForEachKV[K comparable, V any](obj map[K]V, do func(K, V)) {
+	var wg sync.WaitGroup
+	wg.Add(len(obj))
+	for k, v := range obj {
+		go func(k K, v V) {
+			do(k, v)
+			wg.Done()
+		}(k, v)
+	}
+	wg.Wait()
+}

internal/utils/functional/map.go

@@ -0,0 +1,116 @@
+package functional
+
+import (
+	"github.com/puzpuzpuz/xsync/v3"
+	"gopkg.in/yaml.v3"
+
+	E "github.com/yusing/go-proxy/internal/error"
+)
+
+type Map[KT comparable, VT any] struct {
+	*xsync.MapOf[KT, VT]
+}
+
+func NewMapOf[KT comparable, VT any](options ...func(*xsync.MapConfig)) Map[KT, VT] {
+	return Map[KT, VT]{xsync.NewMapOf[KT, VT](options...)}
+}
+
+func NewMapFrom[KT comparable, VT any](m map[KT]VT) (res Map[KT, VT]) {
+	res = NewMapOf[KT, VT](xsync.WithPresize(len(m)))
+	for k, v := range m {
+		res.Store(k, v)
+	}
+	return
+}
+
+func MapFind[KT comparable, VT, CT any](m Map[KT, VT], criteria func(VT) (CT, bool)) (_ CT) {
+	result := make(chan CT, 1)
+
+	m.Range(func(key KT, value VT) bool {
+		select {
+		case <-result: // already have a result
+			return false // stop iteration
+		default:
+			if got, ok := criteria(value); ok {
+				result <- got
+				return false
+			}
+			return true
+		}
+	})
+
+	select {
+	case v := <-result:
+		return v
+	default:
+		return
+	}
+}
+
+// MergeFrom add contents from another `Map`, ignore duplicated keys
+//
+// Parameters:
+// - other: `Map` of values to add from
+//
+// Return:
+// - Map: a `Map` of duplicated keys-value pairs
+func (m Map[KT, VT]) MergeFrom(other Map[KT, VT]) Map[KT, VT] {
+	dups := NewMapOf[KT, VT]()
+
+	other.Range(func(k KT, v VT) bool {
+		if _, ok := m.Load(k); ok {
+			dups.Store(k, v)
+		} else {
+			m.Store(k, v)
+		}
+		return true
+	})
+	return dups
+}
+
+func (m Map[KT, VT]) RangeAll(do func(k KT, v VT)) {
+	m.Range(func(k KT, v VT) bool {
+		do(k, v)
+		return true
+	})
+}
+
+func (m Map[KT, VT]) RemoveAll(criteria func(VT) bool) {
+	m.Range(func(k KT, v VT) bool {
+		if criteria(v) {
+			m.Delete(k)
+		}
+		return true
+	})
+}
+
+func (m Map[KT, VT]) Has(k KT) bool {
+	_, ok := m.Load(k)
+	return ok
+}
+
+func (m Map[KT, VT]) UnmarshalFromYAML(data []byte) E.NestedError {
+	if m.Size() != 0 {
+		return E.FailedWhy("unmarshal from yaml", "map is not empty")
+	}
+	tmp := make(map[KT]VT)
+	if err := E.From(yaml.Unmarshal(data, tmp)); err.HasError() {
+		return err
+	}
+	for k, v := range tmp {
+		m.Store(k, v)
+	}
+	return nil
+}
+
+func (m Map[KT, VT]) String() string {
+	tmp := make(map[KT]VT, m.Size())
+	m.RangeAll(func(k KT, v VT) {
+		tmp[k] = v
+	})
+	data, err := yaml.Marshal(tmp)
+	if err != nil {
+		return err.Error()
+	}
+	return string(data)
+}

internal/utils/functional/map_test.go

@@ -0,0 +1,75 @@
+package functional_test
+
+import (
+	"testing"
+
+	. "github.com/yusing/go-proxy/internal/utils/functional"
+	. "github.com/yusing/go-proxy/internal/utils/testing"
+)
+
+func TestNewMapFrom(t *testing.T) {
+	m := NewMapFrom(map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+	})
+	ExpectEqual(t, m.Size(), 3)
+	ExpectTrue(t, m.Has("a"))
+	ExpectTrue(t, m.Has("b"))
+	ExpectTrue(t, m.Has("c"))
+}
+
+func TestMapFind(t *testing.T) {
+	m := NewMapFrom(map[string]map[string]int{
+		"a": {
+			"a": 1,
+		},
+		"b": {
+			"a": 1,
+			"b": 2,
+		},
+		"c": {
+			"b": 2,
+			"c": 3,
+		},
+	})
+	res := MapFind(m, func(inner map[string]int) (int, bool) {
+		if _, ok := inner["c"]; ok && inner["c"] == 3 {
+			return inner["c"], true
+		}
+		return 0, false
+	})
+	ExpectEqual(t, res, 3)
+}
+
+func TestMergeFrom(t *testing.T) {
+	m1 := NewMapFrom(map[string]int{
+		"a": 1,
+		"b": 2,
+		"c": 3,
+		"d": 4,
+	})
+	m2 := NewMapFrom(map[string]int{
+		"a": 1,
+		"c": 123,
+		"e": 456,
+		"f": 6,
+	})
+	dup := m1.MergeFrom(m2)
+
+	ExpectEqual(t, m1.Size(), 6)
+	ExpectTrue(t, m1.Has("e"))
+	ExpectTrue(t, m1.Has("f"))
+	c, _ := m1.Load("c")
+	d, _ := m1.Load("d")
+	e, _ := m1.Load("e")
+	f, _ := m1.Load("f")
+	ExpectEqual(t, c, 3)
+	ExpectEqual(t, d, 4)
+	ExpectEqual(t, e, 456)
+	ExpectEqual(t, f, 6)
+
+	ExpectEqual(t, dup.Size(), 2)
+	ExpectTrue(t, dup.Has("a"))
+	ExpectTrue(t, dup.Has("c"))
+}

internal/utils/functional/map_utils.go

@@ -0,0 +1,8 @@
+package functional
+
+func FirstValueOf[KT comparable, VT any](m map[KT]VT) (_ VT, ok bool) {
+	for _, v := range m {
+		return v, true
+	}
+	return
+}

internal/utils/functional/slice.go

@@ -0,0 +1,71 @@
+package functional
+
+type Slice[T any] struct {
+	s []T
+}
+
+func NewSlice[T any]() *Slice[T] {
+	return &Slice[T]{make([]T, 0)}
+}
+
+func NewSliceN[T any](n int) *Slice[T] {
+	return &Slice[T]{make([]T, n)}
+}
+
+func NewSliceFrom[T any](s []T) *Slice[T] {
+	return &Slice[T]{s}
+}
+
+func (s *Slice[T]) Size() int {
+	return len(s.s)
+}
+
+func (s *Slice[T]) Empty() bool {
+	return len(s.s) == 0
+}
+
+func (s *Slice[T]) NotEmpty() bool {
+	return len(s.s) > 0
+}
+
+func (s *Slice[T]) Iterator() []T {
+	return s.s
+}
+
+func (s *Slice[T]) Set(i int, v T) {
+	s.s[i] = v
+}
+
+func (s *Slice[T]) Add(e T) *Slice[T] {
+	s.s = append(s.s, e)
+	return s
+}
+
+func (s *Slice[T]) AddRange(other *Slice[T]) *Slice[T] {
+	s.s = append(s.s, other.s...)
+	return s
+}
+
+func (s *Slice[T]) ForEach(do func(T)) {
+	for _, v := range s.s {
+		do(v)
+	}
+}
+
+func (s *Slice[T]) Map(m func(T) T) *Slice[T] {
+	n := make([]T, len(s.s))
+	for i, v := range s.s {
+		n[i] = m(v)
+	}
+	return &Slice[T]{n}
+}
+
+func (s *Slice[T]) Filter(f func(T) bool) *Slice[T] {
+	n := make([]T, 0)
+	for _, v := range s.s {
+		if f(v) {
+			n = append(n, v)
+		}
+	}
+	return &Slice[T]{n}
+}