[chore] pull in latest go-cache, go-runners versions (#1306)

Signed-off-by: kim <grufwub@gmail.com>

Signed-off-by: kim <grufwub@gmail.com>

vendor/codeberg.org/gruf/go-mangler/README.md

@@ -19,8 +19,6 @@ pkg: codeberg.org/gruf/go-mangler
 cpu: 11th Gen Intel(R) Core(TM) i7-1185G7 @ 3.00GHz
 BenchmarkMangle
 BenchmarkMangle-8                         723278              1593 ns/op            1168 B/op        120 allocs/op
-BenchmarkMangleHash
-BenchmarkMangleHash-8                     405380              2788 ns/op            4496 B/op        214 allocs/op
 BenchmarkJSON
 BenchmarkJSON-8                           199360              6116 ns/op            4243 B/op        142 allocs/op
 BenchmarkBinary

vendor/codeberg.org/gruf/go-mangler/load.go

@@ -118,20 +118,16 @@ func loadReflect(t reflect.Type) (Mangler, rMangler) {
 		reflect.Uintptr:
 		return mangle_platform_int, nil
 
-	case reflect.Int8,
-		reflect.Uint8:
+	case reflect.Int8, reflect.Uint8:
 		return mangle_8bit, nil
 
-	case reflect.Int16,
-		reflect.Uint16:
+	case reflect.Int16, reflect.Uint16:
 		return mangle_16bit, nil
 
-	case reflect.Int32,
-		reflect.Uint32:
+	case reflect.Int32, reflect.Uint32:
 		return mangle_32bit, nil
 
-	case reflect.Int64,
-		reflect.Uint64:
+	case reflect.Int64, reflect.Uint64:
 		return mangle_64bit, nil
 
 	case reflect.Float32:
@@ -214,20 +210,16 @@ func loadReflectKnownPtr(et reflect.Type) Mangler {
 		reflect.Uintptr:
 		return mangle_platform_int_ptr
 
-	case reflect.Int8,
-		reflect.Uint8:
+	case reflect.Int8, reflect.Uint8:
 		return mangle_8bit_ptr
 
-	case reflect.Int16,
-		reflect.Uint16:
+	case reflect.Int16, reflect.Uint16:
 		return mangle_16bit_ptr
 
-	case reflect.Int32,
-		reflect.Uint32:
+	case reflect.Int32, reflect.Uint32:
 		return mangle_32bit_ptr
 
-	case reflect.Int64,
-		reflect.Uint64:
+	case reflect.Int64, reflect.Uint64:
 		return mangle_64bit_ptr
 
 	case reflect.Float32:
@@ -261,20 +253,16 @@ func loadReflectKnownSlice(et reflect.Type) Mangler {
 		reflect.Uintptr:
 		return mangle_platform_int_slice
 
-	case reflect.Int8,
-		reflect.Uint8:
+	case reflect.Int8, reflect.Uint8:
 		return mangle_8bit_slice
 
-	case reflect.Int16,
-		reflect.Uint16:
+	case reflect.Int16, reflect.Uint16:
 		return mangle_16bit_slice
 
-	case reflect.Int32,
-		reflect.Uint32:
+	case reflect.Int32, reflect.Uint32:
 		return mangle_32bit_slice
 
-	case reflect.Int64,
-		reflect.Uint64:
+	case reflect.Int64, reflect.Uint64:
 		return mangle_64bit_slice
 
 	case reflect.Float32:
@@ -305,7 +293,7 @@ func loadReflectArray(et reflect.Type) rMangler {
 	return nil
 }
 
-// loadReflectMap ...
+// loadReflectMap loads an rMangler function for a map of given key and value types.
 func loadReflectMap(kt, vt reflect.Type) rMangler {
 	var kmng, vmng rMangler
 

vendor/codeberg.org/gruf/go-mangler/mangle.go

@@ -3,15 +3,13 @@ package mangler
 import (
 	"encoding/binary"
 	"reflect"
+	"sync"
 	"unsafe"
-
-	"github.com/cespare/xxhash"
-	"github.com/cornelk/hashmap"
 )
 
 var (
 	// manglers is a map of runtime type ptrs => Mangler functions.
-	manglers = hashmap.New[uintptr, Mangler]()
+	manglers = sync.Map{}
 
 	// bin is a short-hand for our chosen byteorder encoding.
 	bin = binary.LittleEndian
@@ -36,12 +34,38 @@ type Mangler func(buf []byte, value any) []byte
 type rMangler func(buf []byte, value reflect.Value) []byte
 
 // Get will fetch the Mangler function for given runtime type.
-func Get(t reflect.Type) (Mangler, bool) {
-	if t == nil {
-		return nil, false
-	}
+// Note that the returned mangler will be a no-op in the case
+// that an incorrect type is passed as the value argument.
+func Get(t reflect.Type) Mangler {
+	var mng Mangler
+
+	// Get raw runtime type ptr
 	uptr := uintptr(iface_value(t))
-	return manglers.Get(uptr)
+
+	// Look for a cached mangler
+	v, ok := manglers.Load(uptr)
+
+	if !ok {
+		// Load mangler function
+		mng = loadMangler(nil, t)
+	} else {
+		// cast cached value
+		mng = v.(Mangler)
+	}
+
+	return func(buf []byte, value any) []byte {
+		// Type check passed value against original arg type.
+		if vt := reflect.TypeOf(value); vt != t {
+			return buf
+		}
+
+		// First write the type ptr (this adds
+		// a unique prefix for each runtime type).
+		buf = mangle_platform_int(buf, uptr)
+
+		// Finally, mangle value
+		return mng(buf, value)
+	}
 }
 
 // Register will register the given Mangler function for use with vars of given runtime type. This allows
@@ -57,17 +81,19 @@ func Register(t reflect.Type, m Mangler) {
 	uptr := uintptr(iface_value(t))
 
 	// Ensure this is a unique encoder
-	if _, ok := manglers.Get(uptr); ok {
+	if _, ok := manglers.Load(uptr); ok {
 		panic("already registered mangler for type: " + t.String())
 	}
 
 	// Cache this encoder func
-	manglers.Set(uptr, m)
+	manglers.Store(uptr, m)
 }
 
 // Append will append the mangled form of input value 'a' to buffer 'b'.
 // See mangler.String() for more information on mangled output.
 func Append(b []byte, a any) []byte {
+	var mng Mangler
+
 	// Get reflect type of 'a'
 	t := reflect.TypeOf(a)
 
@@ -75,12 +101,15 @@ func Append(b []byte, a any) []byte {
 	uptr := uintptr(iface_value(t))
 
 	// Look for a cached mangler
-	mng, ok := manglers.Get(uptr)
+	v, ok := manglers.Load(uptr)
 
 	if !ok {
 		// Load mangler into cache
-		mng = loadMangler(a, t)
-		manglers.Set(uptr, mng)
+		mng = loadMangler(nil, t)
+		manglers.Store(uptr, mng)
+	} else {
+		// cast cached value
+		mng = v.(Mangler)
 	}
 
 	// First write the type ptr (this adds
@@ -123,10 +152,3 @@ func String(a any) string {
 	b := Append(make([]byte, 0, 32), a)
 	return *(*string)(unsafe.Pointer(&b))
 }
-
-// Hash returns the xxHash digest of the result of mangler.Append(nil, 'a').
-func Hash(a any) uint64 {
-	b := make([]byte, 0, 32)
-	b = Append(b, a)
-	return xxhash.Sum64(b)
-}