update the readme and regen the files, also add a uint64 cmap by default.

Author: OneOfOne

README.md

@@ -15,6 +15,17 @@ CMap (concurrent-map) is a sharded map implementation to support fast concurrent
 * `stringcmap.CMap` gives a specialized version to support map[string]interface{}.
 * `stringcmap.MapWithJSON` implements json.Unmarshaler with a custom value unmarshaler.
 
+## Typed CMap (using [genx](https://github.com/OneOfOne/genx))
+
+* CMap fully supports generating typed versions, for example [`stringcmap`](https://github.com/OneOfOne/cmap/tree/master/stringcmap)
+is generated by running `go:generate genx -pkg github.com/OneOfOne/cmap -v -n stringcmap -t KT=string,VT=interface{} -fld HashFn -fn DefaultKeyHasher -s "cm.HashFn=hashers.Fnv32" -m -o ./stringcmap/cmap_string_iface.go`
+### How to generate your own?
+```
+	➤ go get -u github.com/OneOfOne/genx/cmd/genx # get or update genx
+	➤ genx -pkg github.com/OneOfOne/cmap -v -m -t KT=pkg.SomeType,VT=interface{} -name newPackageName -o ./cmap_something.go
+	# example:
+	➤ genx -pkg github.com/OneOfOne/cmap -v -m -t KT=uint64,VT=func() -name cbmap -o ./cmap_cbmap.go
+```
 ## FAQ
 
 ### Why?

cmap_iface_iface.go

@@ -1,7 +1,7 @@
 // This file was automatically generated by genx.
 // Any changes will be lost if this file is regenerated.
 // see https://github.com/OneOfOne/genx
-// cmd: genx -pkg github.com/OneOfOne/cmap -v -t KT=interface{},VT=interface{} -m -o ./cmap_iface_iface.go
+// cmd: genx -pkg github.com/OneOfOne/cmap -v -m -t KT=interface{},VT=interface{} -o ./cmap_iface_iface.go
 // +build !genx
 
 package cmap
@@ -20,8 +20,6 @@ const DefaultShardCount = 1 << 8
 type CMap struct {
 	shards   []*LMap
 	keysPool sync.Pool
-	// HashFn allows using a custom hash function that's used to determain the key's shard. Defaults to DefaultKeyHasher.
-	HashFn func(interface{}) uint32
 }
 
 // New is an alias for NewSize(DefaultShardCount)
@@ -40,7 +38,6 @@ func NewSize(shardCount int) *CMap {
 
 	cm := &CMap{
 		shards: make([]*LMap, shardCount),
-		HashFn: DefaultKeyHasher,
 	}
 
 	cm.keysPool.New = func() interface{} {
@@ -58,63 +55,63 @@ func NewSize(shardCount int) *CMap {
 
 // ShardForKey returns the LMap that may hold the specific key.
 func (cm *CMap) ShardForKey(key interface{}) *LMap {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)]
 }
 
 // Set is the equivalent of `map[key] = val`.
 func (cm *CMap) Set(key interface{}, val interface{}) {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	cm.shards[h&uint32(len(cm.shards)-1)].Set(key, val)
 }
 
 // SetIfNotExists will only assign val to key if it wasn't already set.
 // Use `Update` if you need more logic.
 func (cm *CMap) SetIfNotExists(key interface{}, val interface{}) (set bool) {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].SetIfNotExists(key, val)
 }
 
 // Get is the equivalent of `val := map[key]`.
 func (cm *CMap) Get(key interface{}) (val interface{}) {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].Get(key)
 }
 
 // GetOK is the equivalent of `val, ok := map[key]`.
 func (cm *CMap) GetOK(key interface{}) (val interface{}, ok bool) {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].GetOK(key)
 }
 
 // Has is the equivalent of `_, ok := map[key]`.
 func (cm *CMap) Has(key interface{}) bool {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].Has(key)
 }
 
 // Delete is the equivalent of `delete(map, key)`.
 func (cm *CMap) Delete(key interface{}) {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	cm.shards[h&uint32(len(cm.shards)-1)].Delete(key)
 }
 
 // DeleteAndGet is the equivalent of `oldVal := map[key]; delete(map, key)`.
 func (cm *CMap) DeleteAndGet(key interface{}) interface{} {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].DeleteAndGet(key)
 }
 
 // Update calls `fn` with the key's old value (or nil) 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 interface{}, fn func(oldval interface{}) (newval interface{})) {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	cm.shards[h&uint32(len(cm.shards)-1)].Update(key, fn)
 }
 
 // Swap is the equivalent of `oldVal, map[key] = map[key], newVal`.
 func (cm *CMap) Swap(key interface{}, val interface{}) interface{} {
-	h := cm.HashFn(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].Swap(key, val)
 }
 
@@ -166,6 +163,19 @@ func (cm *CMap) Len() int {
 	return ln
 }
 
+// ShardDistribution returns the distribution of data amoung all shards.
+// Useful for debugging the efficiency of a hash.
+func (cm *CMap) ShardDistribution() []float64 {
+	var (
+		out = make([]float64, len(cm.shards))
+		ln  = float64(cm.Len())
+	)
+	for i := range out {
+		out[i] = float64(cm.shards[i].Len()) / ln
+	}
+	return out
+}
+
 // KV holds the key/value returned when Iter is called.
 type KV struct {
 	Key   interface{}
@@ -217,8 +227,7 @@ func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV, locked bool) {
 // NumShards returns the number of shards in the map.
 func (cm *CMap) NumShards() int { return len(cm.shards) }
 
-// DefaultKeyHasher is an alias for hashers.TypeHasher32(key).
-func DefaultKeyHasher(key interface{}) uint32 { return hashers.TypeHasher32(key) }
+func hasher(key interface{}) uint32 { return hashers.TypeHasher32(key) }
 
 // LMap is a simple sync.RWMutex locked map.
 // Used by CMap internally for sharding.
@@ -232,7 +241,7 @@ func NewLMap() *LMap {
 	return NewLMapSize(0)
 }
 
-// NewLMapSize is the equivalent of `m := make(map[KT]VT, cap)`
+// NewLMapSize is the equivalent of `m := make(map[interface{}]interface{}, cap)`
 func NewLMapSize(cap int) *LMap {
 	return &LMap{
 		m: make(map[interface{}]interface{}, cap),

stringcmap/cmap_string_iface.go

@@ -1,7 +1,7 @@
 // This file was automatically generated by genx.
 // Any changes will be lost if this file is regenerated.
 // see https://github.com/OneOfOne/genx
-// cmd: genx -pkg github.com/OneOfOne/cmap -v -n stringcmap -t KT=string,VT=interface{} -fld HashFn -fn DefaultKeyHasher -s cm.HashFn=hashers.Fnv32 -m -o ./stringcmap/cmap_string_iface.go
+// cmd: genx -pkg github.com/OneOfOne/cmap -v -m -n stringcmap -t KT=string,VT=interface{} -o ./stringcmap/cmap_string_iface.go
 // +build !genx
 
 package stringcmap
@@ -55,63 +55,63 @@ func NewSize(shardCount int) *CMap {
 
 // ShardForKey returns the LMap that may hold the specific key.
 func (cm *CMap) ShardForKey(key string) *LMap {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)]
 }
 
 // Set is the equivalent of `map[key] = val`.
 func (cm *CMap) Set(key string, val interface{}) {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	cm.shards[h&uint32(len(cm.shards)-1)].Set(key, val)
 }
 
 // SetIfNotExists will only assign val to key if it wasn't already set.
 // Use `Update` if you need more logic.
 func (cm *CMap) SetIfNotExists(key string, val interface{}) (set bool) {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].SetIfNotExists(key, val)
 }
 
 // Get is the equivalent of `val := map[key]`.
 func (cm *CMap) Get(key string) (val interface{}) {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].Get(key)
 }
 
 // GetOK is the equivalent of `val, ok := map[key]`.
 func (cm *CMap) GetOK(key string) (val interface{}, ok bool) {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].GetOK(key)
 }
 
 // Has is the equivalent of `_, ok := map[key]`.
 func (cm *CMap) Has(key string) bool {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].Has(key)
 }
 
 // Delete is the equivalent of `delete(map, key)`.
 func (cm *CMap) Delete(key string) {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	cm.shards[h&uint32(len(cm.shards)-1)].Delete(key)
 }
 
 // DeleteAndGet is the equivalent of `oldVal := map[key]; delete(map, key)`.
 func (cm *CMap) DeleteAndGet(key string) interface{} {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].DeleteAndGet(key)
 }
 
 // Update calls `fn` with the key's old value (or nil) 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 string, fn func(oldval interface{}) (newval interface{})) {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	cm.shards[h&uint32(len(cm.shards)-1)].Update(key, fn)
 }
 
 // Swap is the equivalent of `oldVal, map[key] = map[key], newVal`.
 func (cm *CMap) Swap(key string, val interface{}) interface{} {
-	h := hashers.Fnv32(key)
+	h := hasher(key)
 	return cm.shards[h&uint32(len(cm.shards)-1)].Swap(key, val)
 }
 
@@ -163,6 +163,19 @@ func (cm *CMap) Len() int {
 	return ln
 }
 
+// ShardDistribution returns the distribution of data amoung all shards.
+// Useful for debugging the efficiency of a hash.
+func (cm *CMap) ShardDistribution() []float64 {
+	var (
+		out = make([]float64, len(cm.shards))
+		ln  = float64(cm.Len())
+	)
+	for i := range out {
+		out[i] = float64(cm.shards[i].Len()) / ln
+	}
+	return out
+}
+
 // KV holds the key/value returned when Iter is called.
 type KV struct {
 	Key   string
@@ -213,6 +226,7 @@ func (cm *CMap) iterContext(ctx context.Context, ch chan<- *KV, locked bool) {
 
 // NumShards returns the number of shards in the map.
 func (cm *CMap) NumShards() int { return len(cm.shards) }
+func hasher(key string) uint32  { return hashers.Fnv32(key) }
 
 // LMap is a simple sync.RWMutex locked map.
 // Used by CMap internally for sharding.
@@ -226,7 +240,7 @@ func NewLMap() *LMap {
 	return NewLMapSize(0)
 }
 
-// NewLMapSize is the equivalent of `m := make(map[KT]VT, cap)`
+// NewLMapSize is the equivalent of `m := make(map[string]interface{}, cap)`
 func NewLMapSize(cap int) *LMap {
 	return &LMap{
 		m: make(map[string]interface{}, cap),