增加计算元素数量方法

abstruct.go

@@ -13,7 +13,7 @@ package easymap
 //
 // Date : 9:56 下午 2021/2/23
 type EasyMap interface {
-	Get(key interface{}) (interface{}, error)
+	Get(key interface{}) (interface{}, bool)
 	GetWithReceiver(key interface{}, dest interface{}) error
 	GetUint(key interface{}) (uint, error)
 	GetUint8(key interface{}) (uint8, error)
@@ -32,6 +32,7 @@ type EasyMap interface {
 	Set(key interface{}, value interface{})
 	Del(key interface{})
 	Exist(key interface{}) bool
+	Count() int
 	GetAll() map[interface{}]interface{}
 	GetAllForMapKeyString() map[string]interface{}
 	// Iterator 对数据的迭代

common.go

@@ -0,0 +1,376 @@
+// Package easymap ...
+//
+// Description : easymap ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 2023-12-14 15:51
+package easymap
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"git.zhangdeman.cn/zhangdeman/serialize"
+	"git.zhangdeman.cn/zhangdeman/util"
+	"sync"
+)
+
+// common 公共基础结构
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 15:52 2023/12/14
+type common struct {
+	normalDataTable  []map[interface{}]interface{} // 普通数组
+	syncMapDataTable []sync.Map                    // sync_map类型
+	dataTableType    string                        // 数据表类型
+	segment          int                           // 分片熟练
+	lock             *sync.RWMutex                 // 数据锁
+}
+
+// initLock ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 21:25 2023/12/24
+func (c *common) initLock() {
+	if c.dataTableType == normalDataTableType {
+		c.lock = &sync.RWMutex{}
+	}
+}
+
+// Lock ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 21:27 2023/12/24
+func (c *common) Lock() {
+	if nil == c.lock {
+		return
+	}
+	c.lock.Lock()
+}
+
+// Unlock ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 21:27 2023/12/24
+func (c *common) Unlock() {
+	if nil == c.lock {
+		return
+	}
+	c.lock.Unlock()
+}
+
+// RLock ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 21:43 2023/12/24
+func (c *common) RLock() {
+	if nil == c.lock {
+		return
+	}
+	c.lock.RLock()
+}
+
+// RUnlock ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 21:43 2023/12/24
+func (c *common) RUnlock() {
+	if nil == c.lock {
+		return
+	}
+	c.lock.RUnlock()
+}
+
+func (c *common) Get(key interface{}) (interface{}, bool) {
+	segmentIndex := util.Hash.GetHashIDMod(key, c.segment)
+	c.RLock()
+	defer c.RUnlock()
+	if c.dataTableType == normalDataTableType {
+		data, exist := c.normalDataTable[segmentIndex][key]
+		return data, exist
+	} else {
+		// sync map
+		return c.syncMapDataTable[segmentIndex].Load(key)
+	}
+}
+
+func (c *common) GetWithReceiver(key interface{}, dest interface{}) error {
+	if nil == dest {
+		return errors.New("dest is nil")
+	}
+	val, exist := c.Get(key)
+	if !exist {
+		return fmt.Errorf("key %v not exist", key)
+	}
+	if nil == val {
+		return errors.New("value is nil")
+	}
+	return util.ConvertAssign(dest, val)
+}
+
+func (c *common) GetUint(key interface{}) (uint, error) {
+	var (
+		val uint
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetUint8(key interface{}) (uint8, error) {
+	var (
+		val uint8
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetUint16(key interface{}) (uint16, error) {
+	var (
+		val uint16
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetUint32(key interface{}) (uint32, error) {
+	var (
+		val uint32
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetUint64(key interface{}) (uint64, error) {
+	var (
+		val uint64
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetInt(key interface{}) (int, error) {
+	var (
+		val int
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetInt8(key interface{}) (int8, error) {
+	var (
+		val int8
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetInt16(key interface{}) (int16, error) {
+	var (
+		val int16
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetInt32(key interface{}) (int32, error) {
+	var (
+		val int32
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetInt64(key interface{}) (int64, error) {
+	var (
+		val int64
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetFloat32(key interface{}) (float32, error) {
+	var (
+		val float32
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetFloat64(key interface{}) (float64, error) {
+	var (
+		val float64
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetBool(key interface{}) (bool, error) {
+	var (
+		val bool
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) GetString(key interface{}) (string, error) {
+	var (
+		val string
+		err error
+	)
+	err = c.GetWithReceiver(key, &val)
+	return val, err
+}
+
+func (c *common) Set(key interface{}, value interface{}) {
+	segmentIndex := util.Hash.GetHashIDMod(key, c.segment)
+	c.Lock()
+	defer c.Unlock()
+	if c.dataTableType == normalDataTableType {
+		c.normalDataTable[segmentIndex][key] = value
+	} else {
+		// sync map
+		c.syncMapDataTable[segmentIndex].Store(key, value)
+	}
+}
+
+func (c *common) Del(key interface{}) {
+	segmentIndex := util.Hash.GetHashIDMod(key, c.segment)
+	c.Lock()
+	defer c.Unlock()
+	if c.dataTableType == normalDataTableType {
+		delete(c.normalDataTable[segmentIndex], key)
+	} else {
+		c.syncMapDataTable[segmentIndex].Delete(key)
+	}
+}
+
+func (c *common) Exist(key interface{}) bool {
+	_, exist := c.Get(key)
+	return exist
+}
+
+// Count 计算元素数量
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 14:21 2024/1/30
+func (c *common) Count() int {
+	cnt := 0
+	c.RLock()
+	defer c.RUnlock()
+	for i := 0; i < c.segment; i++ {
+		cnt = cnt + len(c.normalDataTable[i])
+	}
+	return cnt
+}
+
+func (c *common) GetAll() map[interface{}]interface{} {
+	result := make(map[interface{}]interface{})
+	c.RLock()
+	defer c.RUnlock()
+	for i := 0; i < c.segment; i++ {
+		if c.dataTableType == normalDataTableType {
+			for k, v := range c.normalDataTable[i] {
+				result[k] = v
+			}
+		} else {
+			c.syncMapDataTable[i].Range(func(key, value interface{}) bool {
+				result[key] = value
+				return true
+			})
+		}
+	}
+	return result
+}
+
+// GetAllForMapKeyString ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 9:48 下午 2021/9/15
+func (c *common) GetAllForMapKeyString() map[string]interface{} {
+	fullData := c.GetAll()
+	finalData := make(map[string]interface{})
+	for k, v := range fullData {
+		finalData[fmt.Sprintf("%v", k)] = v
+	}
+	return finalData
+}
+
+// Iterator ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 17:32 2023/3/7
+func (c *common) Iterator(handleFunc IteratorFunc) {
+	if nil == handleFunc {
+		return
+	}
+	c.Lock()
+	c.Unlock()
+	isBreak := false
+	for i := 0; i < c.segment; i++ {
+		if c.dataTableType == normalDataTableType {
+			for k, v := range c.normalDataTable[i] {
+				if !handleFunc(k, v) {
+					isBreak = true
+					break
+				}
+			}
+			if isBreak {
+				break
+			}
+		} else {
+			c.syncMapDataTable[i].Range(func(key, value any) bool {
+				return handleFunc(key, value)
+			})
+		}
+	}
+}
+
+// ToStruct ...
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 15:42 2023/8/10
+func (c *common) ToStruct(receiver interface{}) error {
+	if nil == receiver {
+		return errors.New("receiver is nil")
+	}
+	mapData := c.GetAll()
+	byteData, err := json.Marshal(mapData)
+	if nil != err {
+		return err
+	}
+	return serialize.JSON.UnmarshalWithNumber(byteData, receiver)
+}
+
+// ToString 转字符串
+//
+// Author : go_developer@163.com<白茶清欢>
+//
+// Date : 20:44 2023/8/15
+func (c *common) ToString() string {
+	mapData := c.GetAllForMapKeyString()
+	return serialize.JSON.MarshalForString(mapData)
+}

define.go

@@ -9,3 +9,8 @@ package easymap
 
 // IteratorFunc 迭代函数， 返回值为是否继续迭代，true 继续迭代 false 终止后续迭代
 type IteratorFunc func(key interface{}, value interface{}) bool
+
+const (
+	normalDataTableType  = "NORMAL"
+	syncMapDataTableType = "SYNC_MAP"
+)

go.mod

@@ -1,10 +1,14 @@
 module git.zhangdeman.cn/zhangdeman/easymap
 
-go 1.20
+go 1.21
 
-require git.zhangdeman.cn/zhangdeman/util v0.0.0-20230811070456-d6a489d5860b
+toolchain go1.21.5
+
+require git.zhangdeman.cn/zhangdeman/util v0.0.0-20231014142840-445c6407db92
 
 require (
+	git.zhangdeman.cn/zhangdeman/consts v0.0.0-20230815040024-2b12dd51d19b // indirect
+	git.zhangdeman.cn/zhangdeman/serialize v0.0.0-20231224125439-01f39b6ea08d // indirect
 	github.com/BurntSushi/toml v1.3.2 // indirect
 	github.com/Jeffail/gabs v1.4.0 // indirect
 	github.com/axgle/mahonia v0.0.0-20180208002826-3358181d7394 // indirect

go.sum

@@ -1,7 +1,13 @@
+git.zhangdeman.cn/zhangdeman/consts v0.0.0-20230815040024-2b12dd51d19b h1:C7KftnLh7dOqzNRs5dn/9yqMDvuqMn5RCglvV6bY758=
+git.zhangdeman.cn/zhangdeman/consts v0.0.0-20230815040024-2b12dd51d19b/go.mod h1:IXXaZkb7vGzGnGM5RRWrASAuwrVSNxuoe0DmeXx5g6k=
+git.zhangdeman.cn/zhangdeman/serialize v0.0.0-20231224125439-01f39b6ea08d h1:TV0BCQQewBEtLsv3i9gXkxLFd5A5bWBTiNd3D/I5o4Q=
+git.zhangdeman.cn/zhangdeman/serialize v0.0.0-20231224125439-01f39b6ea08d/go.mod h1:w7kG4zyTJ1uPFaTWhze+OQuaUBINT2XnDxpyiM6ctc0=
 git.zhangdeman.cn/zhangdeman/util v0.0.0-20230810063945-842592611562 h1:wo0r4mexqkPzQ1SZOw5z8A7FJ3ne1G6A/qWR3iaqlhw=
 git.zhangdeman.cn/zhangdeman/util v0.0.0-20230810063945-842592611562/go.mod h1:trYFOShINaQBvinQrH4A0G2kfL22Y2lygEcAiGDt/sc=
 git.zhangdeman.cn/zhangdeman/util v0.0.0-20230811070456-d6a489d5860b h1:vnmxYrNdX6f5sEVjjkM1fIR+i32kHJ4g9DJqug9KKek=
 git.zhangdeman.cn/zhangdeman/util v0.0.0-20230811070456-d6a489d5860b/go.mod h1:Yum5+tgP+Wf1GWUAyQz1Qh8Ab9m5+90GYkYdzqVs0lA=
+git.zhangdeman.cn/zhangdeman/util v0.0.0-20231014142840-445c6407db92 h1:p1GVRYJc3NNoZeLs4CukitAbM3O/ALNq3l31cnbBQDM=
+git.zhangdeman.cn/zhangdeman/util v0.0.0-20231014142840-445c6407db92/go.mod h1:6OBeuwKy2J1TjdAwStEyC6aYC3kStmJiCg1eFC7g0fk=
 github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
 github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
 github.com/Jeffail/gabs v1.4.0 h1://5fYRRTq1edjfIrQGvdkcd22pkYUrHZ5YC/H2GJVAo=

normal.go

@@ -7,334 +7,12 @@
 // Date : 2021-02-23 10:03 下午
 package easymap
 
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"sync"
-
-	"git.zhangdeman.cn/zhangdeman/util"
-)
-
 // NewNormal 获取map实例
 //
 // Author : go_developer@163.com<白茶清欢>
 //
 // Date : 10:07 下午 2021/2/23
-func NewNormal(withLock bool) EasyMap {
-	em := &normal{
-		data:     make(map[interface{}]interface{}),
-		withLock: withLock,
-	}
-	if withLock {
-		em.lock = &sync.RWMutex{}
-	}
+func NewNormal() EasyMap {
+	em, _ := NewSegment(1)
 	return em
 }
-
-// normal 普通map,内部可以加锁
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 10:03 下午 2021/2/23
-type normal struct {
-	data     map[interface{}]interface{}
-	withLock bool
-	lock     *sync.RWMutex
-}
-
-func (n *normal) Get(key interface{}) (interface{}, error) {
-	if !n.Exist(key) {
-		return nil, keyNotFound(key)
-	}
-	n.RLock()
-	defer n.RUnlock()
-	return n.data[key], nil
-}
-
-func (n *normal) GetWithReceiver(key interface{}, dest interface{}) error {
-	var (
-		val interface{}
-		err error
-	)
-	if val, err = n.Get(key); nil != err {
-		return err
-	}
-	return convertFail(util.ConvertAssign(dest, val))
-}
-
-func (n *normal) GetUint(key interface{}) (uint, error) {
-	var (
-		result uint
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetUint8(key interface{}) (uint8, error) {
-	var (
-		result uint8
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetUint16(key interface{}) (uint16, error) {
-	var (
-		result uint16
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetUint32(key interface{}) (uint32, error) {
-	var (
-		result uint32
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetUint64(key interface{}) (uint64, error) {
-	var (
-		result uint64
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetInt(key interface{}) (int, error) {
-	var (
-		result int
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetInt8(key interface{}) (int8, error) {
-	var (
-		result int8
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetInt16(key interface{}) (int16, error) {
-	var (
-		result int16
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetInt32(key interface{}) (int32, error) {
-	var (
-		result int32
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetInt64(key interface{}) (int64, error) {
-	var (
-		result int64
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetFloat32(key interface{}) (float32, error) {
-	var (
-		result float32
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetFloat64(key interface{}) (float64, error) {
-	var (
-		result float64
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetBool(key interface{}) (bool, error) {
-	var (
-		result bool
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return false, err
-	}
-	return result, nil
-}
-
-func (n *normal) GetString(key interface{}) (string, error) {
-	var (
-		result string
-		err    error
-	)
-	if err = n.GetWithReceiver(key, &result); nil != err {
-		return "", err
-	}
-	return result, nil
-}
-
-func (n *normal) Set(key interface{}, value interface{}) {
-	n.Lock()
-	defer n.Unlock()
-	n.data[key] = value
-}
-
-func (n *normal) Del(key interface{}) {
-	n.Lock()
-	defer n.Unlock()
-	delete(n.data, key)
-}
-
-func (n *normal) Exist(key interface{}) bool {
-	n.RLock()
-	defer n.RUnlock()
-	_, exist := n.data[key]
-	return exist
-}
-
-// GetAll 读取全部数据使用的是原始数据深拷贝
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 10:36 下午 2021/2/23
-func (n *normal) GetAll() map[interface{}]interface{} {
-	result := make(map[interface{}]interface{})
-	n.RLock()
-	defer n.RUnlock()
-	for key, val := range n.data {
-		result[key] = val
-	}
-	return result
-}
-
-func (n *normal) RLock() {
-	if n.withLock {
-		n.lock.RLock()
-	}
-}
-
-func (n *normal) RUnlock() {
-	if n.withLock {
-		n.lock.RUnlock()
-	}
-}
-
-func (n *normal) Lock() {
-	if n.withLock {
-		n.lock.Lock()
-	}
-}
-
-func (n *normal) Unlock() {
-	if n.withLock {
-		n.lock.Unlock()
-	}
-}
-
-// GetAllForMapKeyString ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 9:48 下午 2021/9/15
-func (n *normal) GetAllForMapKeyString() map[string]interface{} {
-	fullData := n.GetAll()
-	finalData := make(map[string]interface{})
-	for k, v := range fullData {
-		finalData[fmt.Sprintf("%v", k)] = v
-	}
-	return finalData
-}
-
-// Iterator ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 17:32 2023/3/7
-func (n *normal) Iterator(handleFunc IteratorFunc) {
-	if nil == handleFunc {
-		return
-	}
-	n.RLock()
-	defer n.RUnlock()
-	for key, val := range n.data {
-		if !handleFunc(key, val) {
-			// 终止迭代
-			break
-		}
-	}
-}
-
-// ToStruct map转为结构体
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 15:33 2023/8/10
-func (n *normal) ToStruct(receiver interface{}) error {
-	if nil == receiver {
-		return errors.New("receiver is nil")
-	}
-	mapData := n.GetAll()
-	byteData, err := json.Marshal(mapData)
-	if nil != err {
-		return err
-	}
-	decoder := json.NewDecoder(bytes.NewReader(byteData))
-	decoder.UseNumber()
-	return decoder.Decode(receiver)
-}
-
-// ToString 转字符串
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 20:44 2023/8/15
-func (n *normal) ToString() string {
-	mapData := n.GetAllForMapKeyString()
-	byteData, _ := json.Marshal(mapData)
-	return string(byteData)
-}

segment.go

@@ -7,207 +7,32 @@
 // Date : 2021-02-23 10:47 下午
 package easymap
 
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-
-	"git.zhangdeman.cn/zhangdeman/util"
-)
-
 // NewSegment 获取分段map实例
 //
 // Author : go_developer@163.com<白茶清欢>
 //
 // Date : 11:05 下午 2021/2/24
-func NewSegment(segmentCnt int, withLock bool) (EasyMap, error) {
+func NewSegment(segmentCnt int) (EasyMap, error) {
 	if segmentCnt <= 0 {
 		return nil, segmentError()
 	}
 	em := &segment{
-		segment: segmentCnt,
+		&common{
+			normalDataTable:  nil,
+			syncMapDataTable: nil,
+			dataTableType:    normalDataTableType,
+			segment:          segmentCnt,
+			lock:             nil,
+		},
 	}
-	em.dataTable = make([]EasyMap, segmentCnt)
+	em.normalDataTable = make([]map[interface{}]interface{}, segmentCnt)
 	for i := 0; i < segmentCnt; i++ {
-		em.dataTable[i] = NewNormal(withLock)
+		em.normalDataTable[i] = make(map[interface{}]interface{})
 	}
+	em.common.initLock()
 	return em, nil
 }
 
 type segment struct {
-	dataTable []EasyMap
-	segment   int
-}
-
-func (s *segment) Get(key interface{}) (interface{}, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].Get(key)
-}
-
-func (s *segment) GetWithReceiver(key interface{}, dest interface{}) error {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetWithReceiver(key, dest)
-}
-
-func (s *segment) GetUint(key interface{}) (uint, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetUint(key)
-}
-
-func (s *segment) GetUint8(key interface{}) (uint8, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetUint8(key)
-}
-
-func (s *segment) GetUint16(key interface{}) (uint16, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetUint16(key)
-}
-
-func (s *segment) GetUint32(key interface{}) (uint32, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetUint32(key)
-}
-
-func (s *segment) GetUint64(key interface{}) (uint64, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetUint64(key)
-}
-
-func (s *segment) GetInt(key interface{}) (int, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetInt(key)
-}
-
-func (s *segment) GetInt8(key interface{}) (int8, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetInt8(key)
-}
-
-func (s *segment) GetInt16(key interface{}) (int16, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetInt16(key)
-}
-
-func (s *segment) GetInt32(key interface{}) (int32, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetInt32(key)
-}
-
-func (s *segment) GetInt64(key interface{}) (int64, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetInt64(key)
-}
-
-func (s *segment) GetFloat32(key interface{}) (float32, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetFloat32(key)
-}
-
-func (s *segment) GetFloat64(key interface{}) (float64, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetFloat64(key)
-}
-
-func (s *segment) GetBool(key interface{}) (bool, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetBool(key)
-}
-
-func (s *segment) GetString(key interface{}) (string, error) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].GetString(key)
-}
-
-func (s *segment) Set(key interface{}, value interface{}) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	s.dataTable[segmentIndex].Set(key, value)
-}
-
-func (s *segment) Del(key interface{}) {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	s.dataTable[segmentIndex].Del(key)
-}
-
-func (s *segment) Exist(key interface{}) bool {
-	segmentIndex := util.Hash.GetHashIDMod(key, s.segment)
-	return s.dataTable[segmentIndex].Exist(key)
-}
-
-func (s *segment) GetAll() map[interface{}]interface{} {
-	result := make(map[interface{}]interface{})
-	for i := 0; i < s.segment; i++ {
-		for k, v := range s.dataTable[i].GetAll() {
-			result[k] = v
-		}
-	}
-	return result
-}
-
-// GetAllForMapKeyString ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 9:48 下午 2021/9/15
-func (s *segment) GetAllForMapKeyString() map[string]interface{} {
-	fullData := s.GetAll()
-	finalData := make(map[string]interface{})
-	for k, v := range fullData {
-		finalData[fmt.Sprintf("%v", k)] = v
-	}
-	return finalData
-}
-
-// Iterator ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 17:32 2023/3/7
-func (s *segment) Iterator(handleFunc IteratorFunc) {
-	if nil == handleFunc {
-		return
-	}
-	isBreak := false
-	for i := 0; i < s.segment; i++ {
-		for k, v := range s.dataTable[i].GetAll() {
-			if !handleFunc(k, v) {
-				isBreak = true
-				break
-			}
-		}
-		if isBreak {
-			break
-		}
-	}
-}
-
-// ToStruct ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 15:42 2023/8/10
-func (s *segment) ToStruct(receiver interface{}) error {
-	if nil == receiver {
-		return errors.New("receiver is nil")
-	}
-	mapData := s.GetAll()
-	byteData, err := json.Marshal(mapData)
-	if nil != err {
-		return err
-	}
-	decoder := json.NewDecoder(bytes.NewReader(byteData))
-	decoder.UseNumber()
-	return decoder.Decode(receiver)
-}
-
-// ToString 转字符串
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 20:44 2023/8/15
-func (s *segment) ToString() string {
-	mapData := s.GetAllForMapKeyString()
-	byteData, _ := json.Marshal(mapData)
-	return string(byteData)
+	*common
 }

sync_normal.go

@@ -7,276 +7,7 @@
 // Date : 2021-02-24 2:08 下午
 package easymap
 
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"sync"
-
-	"git.zhangdeman.cn/zhangdeman/util"
-)
-
 func NewSync() EasyMap {
-	return &syncMap{}
-}
-
-type syncMap struct {
-	data sync.Map
-}
-
-func (s *syncMap) Get(key interface{}) (interface{}, error) {
-	val, exist := s.data.Load(key)
-	if !exist {
-		return nil, keyNotFound(key)
-	}
-	return val, nil
-}
-
-func (s *syncMap) GetWithReceiver(key interface{}, dest interface{}) error {
-	var (
-		val interface{}
-		err error
-	)
-	if val, err = s.Get(key); nil != err {
-		return err
-	}
-	if err = util.ConvertAssign(dest, val); nil != err {
-		return convertFail(err)
-	}
-	return nil
-}
-
-func (s *syncMap) GetUint(key interface{}) (uint, error) {
-	var (
-		result uint
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetUint8(key interface{}) (uint8, error) {
-	var (
-		result uint8
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetUint16(key interface{}) (uint16, error) {
-	var (
-		result uint16
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetUint32(key interface{}) (uint32, error) {
-	var (
-		result uint32
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetUint64(key interface{}) (uint64, error) {
-	var (
-		result uint64
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetInt(key interface{}) (int, error) {
-	var (
-		result int
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetInt8(key interface{}) (int8, error) {
-	var (
-		result int8
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetInt16(key interface{}) (int16, error) {
-	var (
-		result int16
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetInt32(key interface{}) (int32, error) {
-	var (
-		result int32
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetInt64(key interface{}) (int64, error) {
-	var (
-		result int64
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetFloat32(key interface{}) (float32, error) {
-	var (
-		result float32
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetFloat64(key interface{}) (float64, error) {
-	var (
-		result float64
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return 0, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetBool(key interface{}) (bool, error) {
-	var (
-		result bool
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return false, err
-	}
-	return result, nil
-}
-
-func (s *syncMap) GetString(key interface{}) (string, error) {
-	var (
-		result string
-		err    error
-	)
-	if err = s.GetWithReceiver(key, &result); nil != err {
-		return "", err
-	}
-	return result, nil
-}
-
-func (s *syncMap) Set(key interface{}, value interface{}) {
-	s.data.Store(key, value)
-}
-
-func (s *syncMap) Del(key interface{}) {
-	s.data.Delete(key)
-}
-
-func (s *syncMap) Exist(key interface{}) bool {
-	_, exist := s.data.Load(key)
-	return exist
-}
-
-func (s *syncMap) GetAll() map[interface{}]interface{} {
-	result := make(map[interface{}]interface{})
-	s.data.Range(func(key, value interface{}) bool {
-		result[key] = value
-		return true
-	})
-	return result
-}
-
-// GetAllForMapKeyString ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 9:48 下午 2021/9/15
-func (s *syncMap) GetAllForMapKeyString() map[string]interface{} {
-	fullData := s.GetAll()
-	finalData := make(map[string]interface{})
-	for k, v := range fullData {
-		finalData[fmt.Sprintf("%v", k)] = v
-	}
-	return finalData
-}
-
-// Iterator 迭代数据
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 17:27 2023/3/7
-func (s *syncMap) Iterator(handleFunc IteratorFunc) {
-	if nil == handleFunc {
-		return
-	}
-	s.data.Range(func(key, value interface{}) bool {
-		return handleFunc(key, value)
-	})
-}
-
-// ToStruct ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 15:47 2023/8/10
-func (s *syncMap) ToStruct(receiver interface{}) error {
-	if nil == receiver {
-		return errors.New("receiver is nil")
-	}
-	mapData := s.GetAll()
-	byteData, err := json.Marshal(mapData)
-	if nil != err {
-		return err
-	}
-	decoder := json.NewDecoder(bytes.NewReader(byteData))
-	decoder.UseNumber()
-	return decoder.Decode(receiver)
-}
-
-// ToString 转字符串
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 20:44 2023/8/15
-func (s *syncMap) ToString() string {
-	mapData := s.GetAllForMapKeyString()
-	byteData, _ := json.Marshal(mapData)
-	return string(byteData)
+	em, _ := NewSegmentSync(1)
+	return em
 }

sync_segment.go

@@ -8,12 +8,7 @@
 package easymap
 
 import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-
-	"git.zhangdeman.cn/zhangdeman/util"
+	"sync"
 )
 
 // NewSegmentSync 获取SegmentSync实例
@@ -26,164 +21,22 @@ func NewSegmentSync(segment int) (EasyMap, error) {
 		return nil, segmentError()
 	}
 	ss := &segmentSync{
-		segment: segment,
+		&common{
+			normalDataTable:  nil,
+			syncMapDataTable: nil,
+			dataTableType:    syncMapDataTableType,
+			segment:          segment,
+			lock:             nil,
+		},
 	}
-	ss.dataTable = make([]EasyMap, segment)
+	ss.syncMapDataTable = make([]sync.Map, segment)
 	for i := 0; i < segment; i++ {
-		ss.dataTable[i] = NewSync()
+		ss.syncMapDataTable[i] = sync.Map{}
 	}
+	ss.initLock()
 	return ss, nil
 }
 
 type segmentSync struct {
-	dataTable []EasyMap
-	segment   int
-}
-
-func (s *segmentSync) Get(key interface{}) (interface{}, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].Get(key)
-}
-
-func (s *segmentSync) GetWithReceiver(key interface{}, dest interface{}) error {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetWithReceiver(key, dest)
-}
-
-func (s *segmentSync) GetUint(key interface{}) (uint, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetUint(key)
-}
-
-func (s *segmentSync) GetUint8(key interface{}) (uint8, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetUint8(key)
-}
-
-func (s *segmentSync) GetUint16(key interface{}) (uint16, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetUint16(key)
-}
-
-func (s *segmentSync) GetUint32(key interface{}) (uint32, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetUint32(key)
-}
-
-func (s *segmentSync) GetUint64(key interface{}) (uint64, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetUint64(key)
-}
-
-func (s *segmentSync) GetInt(key interface{}) (int, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetInt(key)
-}
-
-func (s *segmentSync) GetInt8(key interface{}) (int8, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetInt8(key)
-}
-
-func (s *segmentSync) GetInt16(key interface{}) (int16, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetInt16(key)
-}
-
-func (s *segmentSync) GetInt32(key interface{}) (int32, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetInt32(key)
-}
-
-func (s *segmentSync) GetInt64(key interface{}) (int64, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetInt64(key)
-}
-
-func (s *segmentSync) GetFloat32(key interface{}) (float32, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetFloat32(key)
-}
-
-func (s *segmentSync) GetFloat64(key interface{}) (float64, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetFloat64(key)
-}
-
-func (s *segmentSync) GetBool(key interface{}) (bool, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetBool(key)
-}
-
-func (s *segmentSync) GetString(key interface{}) (string, error) {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].GetString(key)
-}
-
-func (s *segmentSync) Set(key interface{}, value interface{}) {
-	s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].Set(key, value)
-}
-
-func (s *segmentSync) Del(key interface{}) {
-	s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].Del(key)
-}
-
-func (s *segmentSync) Exist(key interface{}) bool {
-	return s.dataTable[util.Hash.GetHashIDMod(key, s.segment)].Exist(key)
-}
-
-func (s *segmentSync) GetAll() map[interface{}]interface{} {
-	result := make(map[interface{}]interface{})
-	for i := 0; i < s.segment; i++ {
-		for k, v := range s.dataTable[i].GetAll() {
-			result[k] = v
-		}
-	}
-	return result
-}
-
-// GetAllForMapKeyString ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 9:48 下午 2021/9/15
-func (s *segmentSync) GetAllForMapKeyString() map[string]interface{} {
-	fullData := s.GetAll()
-	finalData := make(map[string]interface{})
-	for k, v := range fullData {
-		finalData[fmt.Sprintf("%v", k)] = v
-	}
-	return finalData
-}
-
-func (s *segmentSync) Iterator(handleFunc IteratorFunc) {
-	if nil == handleFunc {
-		return
-	}
-	isBreak := false
-	for i := 0; i < s.segment; i++ {
-		for k, v := range s.dataTable[i].GetAll() {
-			if !handleFunc(k, v) {
-				isBreak = true
-				break
-			}
-		}
-		if isBreak {
-			break
-		}
-	}
-}
-
-// ToStruct ...
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 15:48 2023/8/10
-func (s *segmentSync) ToStruct(receiver interface{}) error {
-	if nil == receiver {
-		return errors.New("receiver is nil")
-	}
-	mapData := s.GetAll()
-	byteData, err := json.Marshal(mapData)
-	if nil != err {
-		return err
-	}
-	decoder := json.NewDecoder(bytes.NewReader(byteData))
-	decoder.UseNumber()
-	return decoder.Decode(receiver)
-}
-
-// ToString 转字符串
-//
-// Author : go_developer@163.com<白茶清欢>
-//
-// Date : 20:44 2023/8/15
-func (s *segmentSync) ToString() string {
-	mapData := s.GetAllForMapKeyString()
-	byteData, _ := json.Marshal(mapData)
-	return string(byteData)
+	*common
 }