有序map和辅助函数，移除无用功能

utils/bypassflow/bypassflow.go

@@ -1,57 +0,0 @@
-package bypassflow
-
-import (
-	"context"
-	"go.uber.org/zap"
-	"minotaur/utils/hash"
-	"minotaur/utils/log"
-	"runtime/debug"
-)
-
-// BypassFlow 分流器
-type BypassFlow struct {
-	consistency *hash.Consistency
-	processor   []chan func()
-}
-
-func New(ctx context.Context, nodeCount, nodeBuffer int) *BypassFlow {
-	bypassFlow := &BypassFlow{
-		consistency: &hash.Consistency{},
-		processor:   make([]chan func(), nodeCount),
-	}
-
-	for i := 0; i < nodeCount; i++ {
-		bypassFlow.consistency.AddNode(i)
-
-		nodeChan := make(chan func(), nodeBuffer)
-		bypassFlow.processor[i] = nodeChan
-		go func() {
-			for {
-				select {
-				case f := <-nodeChan:
-					go func() {
-						f()
-						defer func() {
-							if err := recover(); err != nil {
-								log.Error("BypassFlow", zap.Any("error", err), zap.Any("stack\n", debug.Stack()))
-							}
-						}()
-					}()
-				case <-ctx.Done():
-					close(nodeChan)
-					return
-				}
-			}
-		}()
-	}
-	return bypassFlow
-}
-
-func (slf *BypassFlow) getNode(item Item) int {
-	return slf.consistency.PickNode(item)
-}
-
-func (slf *BypassFlow) Handle(item Item, handleFunc func()) {
-	node := slf.getNode(item)
-	slf.processor[node] <- handleFunc
-}

utils/bypassflow/item.go

@@ -1,5 +0,0 @@
-package bypassflow
-
-type Item interface {
-	UniqueIdentification() any
-}

utils/hash/convert.go

@@ -0,0 +1,28 @@
+package hash
+
+// ToSlice 将 map 的 value 转换为切片
+func ToSlice[K comparable, V any](m map[K]V) []V {
+	var s = make([]V, 0, len(m))
+	for _, v := range m {
+		s = append(s, v)
+	}
+	return s
+}
+
+// KeyToSlice 将 map 的 key 转换为切片
+func KeyToSlice[K comparable, V any](m map[K]V) []K {
+	var s = make([]K, 0, len(m))
+	for k := range m {
+		s = append(s, k)
+	}
+	return s
+}
+
+// Reversal 将 map 的 key 和 value 互换
+func Reversal[K comparable, V comparable](m map[K]V) map[V]K {
+	var nm = make(map[V]K)
+	for k, v := range m {
+		nm[v] = k
+	}
+	return nm
+}

utils/hash/srot_map.go

@@ -0,0 +1,94 @@
+package hash
+
+import (
+	"sort"
+)
+
+// SortMap 有序的 map 实现
+type SortMap[K comparable, V any] struct {
+	i int
+	m map[K]V
+	s map[int]K
+	r map[K]int
+}
+
+func (slf *SortMap[K, V]) Set(key K, value V) {
+	if slf.m == nil {
+		slf.m = make(map[K]V)
+	}
+	if slf.s == nil {
+		slf.s = make(map[int]K)
+	}
+	if slf.r == nil {
+		slf.r = make(map[K]int)
+	}
+
+	if i, exist := slf.r[key]; exist {
+		slf.s[i] = key
+		slf.m[key] = value
+	} else {
+		slf.m[key] = value
+		slf.s[slf.i] = key
+		slf.r[key] = slf.i
+		slf.i++
+	}
+}
+
+func (slf *SortMap[K, V]) Del(key K) {
+	if _, exist := slf.m[key]; exist {
+		delete(slf.s, slf.r[key])
+		delete(slf.r, key)
+		delete(slf.m, key)
+	}
+}
+
+func (slf SortMap[K, V]) Get(key K) V {
+	v := slf.m[key]
+	return v
+}
+
+func (slf SortMap[K, V]) For(handle func(key K, value V) bool) {
+	for k, v := range slf.m {
+		if !handle(k, v) {
+			break
+		}
+	}
+}
+
+func (slf SortMap[K, V]) ForSort(handle func(key K, value V) bool) {
+	var indexes []int
+	for i, _ := range slf.s {
+		indexes = append(indexes, i)
+	}
+	sort.Ints(indexes)
+	for _, i := range indexes {
+		k := slf.s[i]
+		if !handle(k, slf.m[k]) {
+			break
+		}
+	}
+}
+
+func (slf SortMap[K, V]) ToMap() map[K]V {
+	var m = make(map[K]V)
+	for k, v := range slf.m {
+		m[k] = v
+	}
+	return m
+}
+
+func (slf SortMap[K, V]) ToSlice() []V {
+	var s = make([]V, 0, len(slf.m))
+	for _, v := range slf.m {
+		s = append(s, v)
+	}
+	return s
+}
+
+func (slf SortMap[K, V]) KeyToSlice() []K {
+	var s = make([]K, 0, len(slf.m))
+	for k := range slf.m {
+		s = append(s, k)
+	}
+	return s
+}