using ghetto code gen to make it easier, should move to an actual codegen package

Author: OneOfOne

cmap.go

@@ -1,3 +1,7 @@
+// AUTO-GENERATED by mapSpec.sh
+// DO NOT EDIT
+// generated from https://github.com/OneOfOne/cmap/tree/master/internal/cmap
+
 package cmap
 
 import (
@@ -6,21 +10,16 @@ import (
 )
 
 type KV struct {
-	Key   KT
-	Value VT
+	Key   interface{}
+	Value interface{}
 }
 
-// DefaultShardCount is the default number of shards to use when New() or NewFromJSON() are called.
-// The default is 256.
-const DefaultShardCount = 1 << 8
-
 // CMap is a concurrent safe sharded map to scale on multiple cores.
 type CMap struct {
-	shards []*lmap
+	shards []*LockedMap
 	// HashFn allows using a custom hash function that's used to determain the key's shard.
-	// Defaults to DefaultKeyHasher
-	HashFn func(KT) uint32
-
+	// Defaults to DefaultKeyHasher.
+	HashFn   func(interface{}) uint32
 	keysPool sync.Pool
 	mod      uint32
 }
@@ -38,49 +37,43 @@ func NewSize(shardCount int) *CMap {
 	} else if shardCount&(shardCount-1) != 0 {
 		panic("shardCount must be a power of 2")
 	}
-
 	cm := &CMap{
-		shards: make([]*lmap, shardCount),
+		shards: make([]*LockedMap, shardCount),
 		mod:    uint32(shardCount) - 1,
 		HashFn: DefaultKeyHasher,
 	}
-
 	for i := range cm.shards {
-		cm.shards[i] = newLmap(shardCount)
+		cm.shards[i] = NewLockedMapSize(shardCount)
 	}
-
 	cm.keysPool.New = func() interface{} {
-		out := make([]KT, 0, shardCount) // good starting round
-
-		return &out // return a ptr to avoid extra allocation on Get/Put
+		out := make([]interface{}, 0, shardCount) // good starting round
+		return &out                               // return a ptr to avoid extra allocation on Get/Put
 	}
-
 	return cm
 }
-
-func (cm *CMap) shard(key KT) *lmap {
+func (cm *CMap) shard(key interface{}) *LockedMap {
 	h := cm.HashFn(key)
 	return cm.shards[h&cm.mod]
 }
 
 // Get is the equivalent of `val := map[key]`.
-func (cm *CMap) Get(key KT) (val VT) {
+func (cm *CMap) Get(key interface{}) (val interface{}) {
 	return cm.shard(key).Get(key)
 }
 
 // GetOK is the equivalent of `val, ok := map[key]`.
-func (cm *CMap) GetOK(key KT) (val VT, ok bool) {
+func (cm *CMap) GetOK(key interface{}) (val interface{}, ok bool) {
 	return cm.shard(key).GetOK(key)
 }
 
 // Set is the equivalent of `map[key] = val`.
-func (cm *CMap) Set(key KT, val VT) {
+func (cm *CMap) Set(key interface{}, val interface{}) {
 	cm.shard(key).Set(key, val)
 }
 
 // SetIfNotExists will only assign val to key if it wasn't already set.
 // Use `CMap.Update` if you need more logic.
-func (cm *CMap) SetIfNotExists(key KT, val VT) (set bool) {
+func (cm *CMap) SetIfNotExists(key interface{}, val interface{}) (set bool) {
 	sh := cm.shard(key)
 	sh.l.Lock()
 	if _, ok := sh.m[key]; !ok {
@@ -91,28 +84,28 @@ func (cm *CMap) SetIfNotExists(key KT, val VT) (set bool) {
 }
 
 // Has is the equivalent of `_, ok := map[key]`.
-func (cm *CMap) Has(key KT) bool { return cm.shard(key).Has(key) }
+func (cm *CMap) Has(key interface{}) bool { return cm.shard(key).Has(key) }
 
 // Delete is the equivalent of `delete(map, key)`.
-func (cm *CMap) Delete(key KT) { cm.shard(key).Delete(key) }
+func (cm *CMap) Delete(key interface{}) { cm.shard(key).Delete(key) }
 
 // DeleteAndGet is the equivalent of `oldVal := map[key]; delete(map, key)`.
-func (cm *CMap) DeleteAndGet(key KT) VT { return cm.shard(key).DeleteAndGet(key) }
+func (cm *CMap) DeleteAndGet(key interface{}) interface{} { return cm.shard(key).DeleteAndGet(key) }
 
 // Update calls `fn` with the key's old value (or nil if it didn't exist) and assign the returned value to the key.
 // The shard containing the key will be locked, it is NOT safe to call other cmap funcs inside `fn`.
-func (cm *CMap) Update(key KT, fn func(oldval VT) (newval VT)) {
+func (cm *CMap) Update(key interface{}, fn func(oldval interface{}) (newval interface{})) {
 	cm.shard(key).Update(key, fn)
 }
 
 // Swap is the equivalent of `oldVal, map[key] = map[key], newVal`.
-func (cm *CMap) Swap(key KT, val VT) VT {
+func (cm *CMap) Swap(key interface{}, val interface{}) interface{} {
 	return cm.shard(key).Swap(key, val)
 }
 
 // Keys returns a slice of all the keys of the map.
-func (cm *CMap) Keys() []KT {
-	out := make([]KT, 0, cm.Len())
+func (cm *CMap) Keys() []interface{} {
+	out := make([]interface{}, 0, cm.Len())
 	for i := range cm.shards {
 		sh := cm.shards[i]
 		sh.l.RLock()
@@ -125,11 +118,10 @@ func (cm *CMap) Keys() []KT {
 }
 
 // ForEach loops over all the key/values in all the shards in order.
-// You can break early by returning an error.
+// You can break early by returning an error or Break.
 // It **is** safe to modify the map while using this iterator, however it uses more memory and is slightly slower.
-func (cm *CMap) ForEach(fn func(key KT, val VT) error) error {
-	keysP := cm.keysPool.Get().(*[]KT)
-
+func (cm *CMap) ForEach(fn func(key interface{}, val interface{}) error) error {
+	keysP := cm.keysPool.Get().(*[]interface{})
 	defer cm.keysPool.Put(keysP)
 	for i := range cm.shards {
 		keys := (*keysP)[:0]
@@ -144,9 +136,9 @@ func (cm *CMap) ForEach(fn func(key KT, val VT) error) error {
 }
 
 // ForEachLocked loops over all the key/values in the map.
-// You can break early by returning an error.
+// You can break early by returning an error or Break.
 // It is **NOT* safe to modify the map while using this iterator.
-func (cm *CMap) ForEachLocked(fn func(key KT, val VT) error) error {
+func (cm *CMap) ForEachLocked(fn func(key interface{}, val interface{}) error) error {
 	for i := range cm.shards {
 		if err := cm.shards[i].ForEachLocked(fn); err != nil {
 			if err == Break {
@@ -181,9 +173,8 @@ func (cm *CMap) IterLocked(ctx context.Context, buffer int) <-chan *KV {
 	}()
 	return ch
 }
-
 func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV, locked bool) {
-	fn := func(k KT, v VT) error {
+	fn := func(k interface{}, v interface{}) error {
 		select {
 		case <-ctx.Done():
 			return Break
@@ -209,3 +200,100 @@ func (cm *CMap) Len() int {
 
 // NumShards returns the number of shards in the map.
 func (cm *CMap) NumShards() int { return len(cm.shards) }
+
+type LockedMap struct {
+	m map[interface{}]interface{}
+	l *sync.RWMutex
+}
+
+func NewLockedMap() *LockedMap {
+	return NewLockedMapSize(0)
+}
+func NewLockedMapSize(cap int) *LockedMap {
+	return &LockedMap{
+		m: make(map[interface{}]interface{}, cap),
+		l: new(sync.RWMutex),
+	}
+}
+func (lm LockedMap) Set(key interface{}, v interface{}) {
+	lm.l.Lock()
+	lm.m[key] = v
+	lm.l.Unlock()
+}
+func (lm LockedMap) Update(key interface{}, fn func(oldVal interface{}) (newVal interface{})) {
+	lm.l.Lock()
+	lm.m[key] = fn(lm.m[key])
+	lm.l.Unlock()
+}
+func (lm LockedMap) Swap(key interface{}, newV interface{}) (oldV interface{}) {
+	lm.l.Lock()
+	oldV = lm.m[key]
+	lm.m[key] = newV
+	lm.l.Unlock()
+	return
+}
+func (lm LockedMap) Get(key interface{}) (v interface{}) {
+	lm.l.RLock()
+	v = lm.m[key]
+	lm.l.RUnlock()
+	return
+}
+func (lm LockedMap) GetOK(key interface{}) (v interface{}, ok bool) {
+	lm.l.RLock()
+	v, ok = lm.m[key]
+	lm.l.RUnlock()
+	return
+}
+func (lm LockedMap) Has(key interface{}) (ok bool) {
+	lm.l.RLock()
+	_, ok = lm.m[key]
+	lm.l.RUnlock()
+	return
+}
+func (lm LockedMap) Delete(key interface{}) {
+	lm.l.Lock()
+	delete(lm.m, key)
+	lm.l.Unlock()
+}
+func (lm LockedMap) DeleteAndGet(key interface{}) (v interface{}) {
+	lm.l.Lock()
+	v = lm.m[key]
+	delete(lm.m, key)
+	lm.l.Unlock()
+	return v
+}
+func (lm LockedMap) Len() (ln int) {
+	lm.l.RLock()
+	ln = len(lm.m)
+	lm.l.RUnlock()
+	return
+}
+func (lm LockedMap) ForEach(keys []interface{}, fn func(key interface{}, val interface{}) error) (err error) {
+	lm.l.RLock()
+	for key := range lm.m {
+		keys = append(keys, key)
+	}
+	lm.l.RUnlock()
+	for _, key := range keys {
+		lm.l.RLock()
+		val, ok := lm.m[key]
+		lm.l.RUnlock()
+		if !ok {
+			continue
+		}
+		if err = fn(key, val); err != nil {
+			return
+		}
+	}
+	return
+}
+func (lm LockedMap) ForEachLocked(fn func(key interface{}, val interface{}) error) (err error) {
+	lm.l.RLock()
+	defer lm.l.RUnlock()
+	for key, val := range lm.m {
+		if err = fn(key, val); err != nil {
+			return
+		}
+	}
+	return
+}

hashers/common.go

@@ -0,0 +1,116 @@
+package hashers
+
+import (
+	"fmt"
+	"math"
+)
+
+// KeyHasher is a type that provides its own hash function.
+type KeyHasher interface {
+	Hash() uint64
+}
+
+// TypeHasher32 returns a hash for the specific key for internal sharding.
+// By default, those types are supported as keys: KeyHasher, string, uint64, int64, uint32, int32, uint16, int16, uint8,
+// int8, uint, int, float64, float32 and fmt.Stringer.
+func TypeHasher32(v interface{}) uint32 {
+	switch v := v.(type) {
+	case KeyHasher:
+		return MixHash32(uint32(v.Hash()))
+	case string:
+		return Fnv32(v)
+	case int:
+		return MixHash32(uint32(v))
+	case uint:
+		return MixHash32(uint32(v))
+	case uint64:
+		return MixHash32(uint32(v))
+	case int64:
+		return MixHash32(uint32(v))
+	case uint32:
+		return MixHash32(uint32(v))
+	case int32:
+		return MixHash32(uint32(v))
+	case uint16:
+		return MixHash32(uint32(v))
+	case int16:
+		return MixHash32(uint32(v))
+	case uint8:
+		return MixHash32(uint32(v))
+	case int8:
+		return MixHash32(uint32(v))
+	case float64:
+		return MixHash32(uint32(math.Float64bits(v)))
+	case float32:
+		return MixHash32(uint32(math.Float32bits(v)))
+	case fmt.Stringer:
+		return Fnv32(v.String())
+	default:
+		panic(fmt.Sprintf("unsupported type: %T (%v)", v, v))
+	}
+}
+
+// TypeHasher64 returns a hash for the specific key for internal sharding.
+// By default, those types are supported as keys: KeyHasher, string, uint64, int64, uint32, int32, uint16, int16, uint8,
+// int8, uint, int, float64, float32 and fmt.Stringer.
+func TypeHasher64(v interface{}) uint64 {
+	switch v := v.(type) {
+	case KeyHasher:
+		return MixHash64(v.Hash())
+	case string:
+		return Fnv64(v)
+	case int:
+		return MixHash64(uint64(v))
+	case uint:
+		return MixHash64(uint64(v))
+	case uint64:
+		return MixHash64(v)
+	case int64:
+		return MixHash64(uint64(v))
+	case uint32:
+		return MixHash64(uint64(v))
+	case int32:
+		return MixHash64(uint64(v))
+	case uint16:
+		return MixHash64(uint64(v))
+	case int16:
+		return MixHash64(uint64(v))
+	case uint8:
+		return MixHash64(uint64(v))
+	case int8:
+		return MixHash64(uint64(v))
+	case float64:
+		return MixHash64(math.Float64bits(v))
+	case float32:
+		return MixHash64(uint64(math.Float32bits(v)))
+	case fmt.Stringer:
+		return Fnv64(v.String())
+	default:
+		panic(fmt.Sprintf("unsupported type: %T (%v)", v, v))
+	}
+}
+
+// MixHash32 mixes the hash to make sure the bits are spread, borrowed from xxhash.
+func MixHash32(h uint32) uint32 {
+	const prime32x2 = 2246822519
+	const prime32x3 = 3266489917
+	h ^= h >> 15
+	h *= prime32x2
+	h ^= h >> 13
+	h *= prime32x3
+	h ^= h >> 16
+	return h
+}
+
+// MixHash64 mixes the hash to make sure the bits are spread, borrowed from xxhash.
+func MixHash64(h uint64) uint64 {
+	const prime64x2 = 14029467366897019727
+	const prime64x3 = 1609587929392839161
+
+	h ^= h >> 33
+	h *= prime64x2
+	h ^= h >> 29
+	h *= prime64x3
+	h ^= h >> 32
+	return h
+}