libs/common: Refactor libs/common 5 (#4240)

* libs/common: Refactor libs/common 5

- move mathematical functions and types out of `libs/common` to math pkg
- move net functions out of `libs/common` to net pkg
- move string functions out of `libs/common` to strings pkg
- move async functions out of `libs/common` to async pkg
- move bit functions out of `libs/common` to bits pkg
- move cmap functions out of `libs/common` to cmap pkg
- move os functions out of `libs/common` to os pkg

Signed-off-by: Marko Baricevic <marbar3778@yahoo.com>

* fix testing issues

* fix tests

closes #41417

woooooooooooooooooo kill the cmn pkg

Signed-off-by: Marko Baricevic <marbar3778@yahoo.com>

* add changelog entry

* fix goimport issues

* run gofmt

libs/cmap/cmap.go

@@ -0,0 +1,75 @@
+package cmap
+
+import "sync"
+
+// CMap is a goroutine-safe map
+type CMap struct {
+	m map[string]interface{}
+	l sync.Mutex
+}
+
+func NewCMap() *CMap {
+	return &CMap{
+		m: make(map[string]interface{}),
+	}
+}
+
+func (cm *CMap) Set(key string, value interface{}) {
+	cm.l.Lock()
+	cm.m[key] = value
+	cm.l.Unlock()
+}
+
+func (cm *CMap) Get(key string) interface{} {
+	cm.l.Lock()
+	val := cm.m[key]
+	cm.l.Unlock()
+	return val
+}
+
+func (cm *CMap) Has(key string) bool {
+	cm.l.Lock()
+	_, ok := cm.m[key]
+	cm.l.Unlock()
+	return ok
+}
+
+func (cm *CMap) Delete(key string) {
+	cm.l.Lock()
+	delete(cm.m, key)
+	cm.l.Unlock()
+}
+
+func (cm *CMap) Size() int {
+	cm.l.Lock()
+	size := len(cm.m)
+	cm.l.Unlock()
+	return size
+}
+
+func (cm *CMap) Clear() {
+	cm.l.Lock()
+	cm.m = make(map[string]interface{})
+	cm.l.Unlock()
+}
+
+func (cm *CMap) Keys() []string {
+	cm.l.Lock()
+
+	keys := make([]string, 0, len(cm.m))
+	for k := range cm.m {
+		keys = append(keys, k)
+	}
+	cm.l.Unlock()
+	return keys
+}
+
+func (cm *CMap) Values() []interface{} {
+	cm.l.Lock()
+	items := make([]interface{}, 0, len(cm.m))
+	for _, v := range cm.m {
+		items = append(items, v)
+	}
+	cm.l.Unlock()
+	return items
+}

libs/cmap/cmap_test.go

@@ -0,0 +1,69 @@
+package cmap
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestIterateKeysWithValues(t *testing.T) {
+	cmap := NewCMap()
+
+	for i := 1; i <= 10; i++ {
+		cmap.Set(fmt.Sprintf("key%d", i), fmt.Sprintf("value%d", i))
+	}
+
+	// Testing size
+	assert.Equal(t, 10, cmap.Size())
+	assert.Equal(t, 10, len(cmap.Keys()))
+	assert.Equal(t, 10, len(cmap.Values()))
+
+	// Iterating Keys, checking for matching Value
+	for _, key := range cmap.Keys() {
+		val := strings.Replace(key, "key", "value", -1)
+		assert.Equal(t, val, cmap.Get(key))
+	}
+
+	// Test if all keys are within []Keys()
+	keys := cmap.Keys()
+	for i := 1; i <= 10; i++ {
+		assert.Contains(t, keys, fmt.Sprintf("key%d", i), "cmap.Keys() should contain key")
+	}
+
+	// Delete 1 Key
+	cmap.Delete("key1")
+
+	assert.NotEqual(
+		t,
+		len(keys),
+		len(cmap.Keys()),
+		"[]keys and []Keys() should not be equal, they are copies, one item was removed",
+	)
+}
+
+func TestContains(t *testing.T) {
+	cmap := NewCMap()
+
+	cmap.Set("key1", "value1")
+
+	// Test for known values
+	assert.True(t, cmap.Has("key1"))
+	assert.Equal(t, "value1", cmap.Get("key1"))
+
+	// Test for unknown values
+	assert.False(t, cmap.Has("key2"))
+	assert.Nil(t, cmap.Get("key2"))
+}
+
+func BenchmarkCMapHas(b *testing.B) {
+	m := NewCMap()
+	for i := 0; i < 1000; i++ {
+		m.Set(string(i), i)
+	}
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		m.Has(string(i))
+	}
+}