Compare commits

..

No commits in common. "master" and "feature/upgrade" have entirely different histories.

10 changed files with 968 additions and 521 deletions

View File

@ -13,38 +13,31 @@ package easymap
// //
// Date : 9:56 下午 2021/2/23 // Date : 9:56 下午 2021/2/23
type EasyMap interface { type EasyMap interface {
Get(key any) (any, bool) Get(key interface{}) (interface{}, error)
GetWithReceiver(key any, dest any) error GetWithReceiver(key interface{}, dest interface{}) error
GetUint(key any) (uint, error) GetUint(key interface{}) (uint, error)
GetUint8(key any) (uint8, error) GetUint8(key interface{}) (uint8, error)
GetUint16(key any) (uint16, error) GetUint16(key interface{}) (uint16, error)
GetUint32(key any) (uint32, error) GetUint32(key interface{}) (uint32, error)
GetUint64(key any) (uint64, error) GetUint64(key interface{}) (uint64, error)
GetInt(key any) (int, error) GetInt(key interface{}) (int, error)
GetInt8(key any) (int8, error) GetInt8(key interface{}) (int8, error)
GetInt16(key any) (int16, error) GetInt16(key interface{}) (int16, error)
GetInt32(key any) (int32, error) GetInt32(key interface{}) (int32, error)
GetInt64(key any) (int64, error) GetInt64(key interface{}) (int64, error)
GetFloat32(key any) (float32, error) GetFloat32(key interface{}) (float32, error)
GetFloat64(key any) (float64, error) GetFloat64(key interface{}) (float64, error)
GetBool(key any) (bool, error) GetBool(key interface{}) (bool, error)
GetString(key any) (string, error) GetString(key interface{}) (string, error)
Set(key any, value any) Set(key interface{}, value interface{})
Del(key any) Del(key interface{})
Exist(key any) bool Exist(key interface{}) bool
Count() int GetAll() map[interface{}]interface{}
GetAll() map[any]any GetAllForMapKeyString() map[string]interface{}
GetAllForMapKeyString() map[string]any
// Merge 合并数据
Merge(mergeData ...EasyMap)
// MergeWithReceiver 合并数据并转换
MergeWithReceiver(receiver any, mergeData ...EasyMap) error
// Iterator 对数据的迭代 // Iterator 对数据的迭代
Iterator(IteratorFunc) Iterator(IteratorFunc)
// ToStruct 转换成结构体 // ToStruct 转换成结构体
ToStruct(receiver any) error ToStruct(receiver interface{}) error
// ToString 转为字符串 // ToString 转为字符串
ToString() string ToString() string
// Filter 过滤数据
Filter(ignoreFieldList []string, rewriteFieldTable map[string]string) map[string]any
} }

434
common.go
View File

@ -1,434 +0,0 @@
// 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[any]any // 普通数组
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 any) (any, 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 any, dest any) 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 any) (uint, error) {
var (
val uint
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetUint8(key any) (uint8, error) {
var (
val uint8
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetUint16(key any) (uint16, error) {
var (
val uint16
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetUint32(key any) (uint32, error) {
var (
val uint32
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetUint64(key any) (uint64, error) {
var (
val uint64
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetInt(key any) (int, error) {
var (
val int
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetInt8(key any) (int8, error) {
var (
val int8
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetInt16(key any) (int16, error) {
var (
val int16
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetInt32(key any) (int32, error) {
var (
val int32
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetInt64(key any) (int64, error) {
var (
val int64
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetFloat32(key any) (float32, error) {
var (
val float32
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetFloat64(key any) (float64, error) {
var (
val float64
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetBool(key any) (bool, error) {
var (
val bool
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) GetString(key any) (string, error) {
var (
val string
err error
)
err = c.GetWithReceiver(key, &val)
return val, err
}
func (c *common) Set(key any, value any) {
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 any) {
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 any) 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[any]any {
result := make(map[any]any)
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 any) 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]any {
fullData := c.GetAll()
finalData := make(map[string]any)
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 any) 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.MarshalForStringIgnoreError(mapData)
}
// Filter 对数据进行过滤
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 16:25 2024/3/8
func (c *common) Filter(ignoreFieldList []string, rewriteFieldTable map[string]string) map[string]any {
if nil == ignoreFieldList {
ignoreFieldList = make([]string, 0)
}
if nil == rewriteFieldTable {
rewriteFieldTable = make(map[string]string)
}
result := make(map[string]any)
ignoreFieldTable := make(map[string]bool)
for _, item := range ignoreFieldList {
ignoreFieldTable[item] = true
}
data := c.GetAllForMapKeyString()
for field, val := range data {
if _, exist := ignoreFieldTable[field]; exist {
// 忽略当前字段
continue
}
if rewriteField, exist := rewriteFieldTable[field]; exist && len(rewriteField) > 0 {
field = rewriteField
}
result[field] = val
}
return result
}
// Merge 合并数据
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 11:01 2024/3/11
func (c *common) Merge(mergeData ...EasyMap) {
for _, itemData := range mergeData {
allData := itemData.GetAll()
for k, v := range allData {
c.Set(k, v)
}
}
}
// MergeWithReceiver 合并并转换
//
// Author : go_developer@163.com<白茶清欢>
//
// Date : 11:06 2024/3/11
func (c *common) MergeWithReceiver(receiver any, mergeData ...EasyMap) error {
c.Merge(mergeData...)
if nil == receiver {
return nil
}
return c.ToStruct(receiver)
}

View File

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

View File

@ -17,7 +17,7 @@ import (
// Author : go_developer@163.com<白茶清欢> // Author : go_developer@163.com<白茶清欢>
// //
// Date : 10:17 下午 2021/2/23 // Date : 10:17 下午 2021/2/23
func keyNotFound(key any) error { func keyNotFound(key interface{}) error {
return fmt.Errorf("%v 未找到", key) return fmt.Errorf("%v 未找到", key)
} }

12
go.mod
View File

@ -1,17 +1,11 @@
module git.zhangdeman.cn/zhangdeman/easymap module git.zhangdeman.cn/zhangdeman/easymap
go 1.21 go 1.20
toolchain go1.21.5 require git.zhangdeman.cn/zhangdeman/util v0.0.0-20230811070456-d6a489d5860b
require ( require (
git.zhangdeman.cn/zhangdeman/serialize v0.0.0-20241023104258-2e0a298aa558 github.com/BurntSushi/toml v1.3.2 // indirect
git.zhangdeman.cn/zhangdeman/util v0.0.0-20240618042405-6ee2c904644e
)
require (
git.zhangdeman.cn/zhangdeman/consts v0.0.0-20241023090605-10cff9173059 // indirect
github.com/BurntSushi/toml v1.4.0 // indirect
github.com/Jeffail/gabs v1.4.0 // indirect github.com/Jeffail/gabs v1.4.0 // indirect
github.com/axgle/mahonia v0.0.0-20180208002826-3358181d7394 // indirect github.com/axgle/mahonia v0.0.0-20180208002826-3358181d7394 // indirect
github.com/dgrijalva/jwt-go/v4 v4.0.0-preview1 // indirect github.com/dgrijalva/jwt-go/v4 v4.0.0-preview1 // indirect

14
go.sum
View File

@ -1,23 +1,9 @@
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/consts v0.0.0-20241023090605-10cff9173059 h1:TPAYdTKKUjgxtCnK38d1Tb4teyQp1C7wYHPdR32yZtM=
git.zhangdeman.cn/zhangdeman/consts v0.0.0-20241023090605-10cff9173059/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/serialize v0.0.0-20241023104258-2e0a298aa558 h1:ZVJyyDKfYeA3TsN8UOi4IprkouK4wIIfCKe+F9byLWA=
git.zhangdeman.cn/zhangdeman/serialize v0.0.0-20241023104258-2e0a298aa558/go.mod h1:/9eicss/Dt9tp2jwZ/4cXDqDKo/Dez+HuT5/NGdqW+s=
git.zhangdeman.cn/zhangdeman/util v0.0.0-20230810063945-842592611562 h1:wo0r4mexqkPzQ1SZOw5z8A7FJ3ne1G6A/qWR3iaqlhw= 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-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 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-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=
git.zhangdeman.cn/zhangdeman/util v0.0.0-20240618042405-6ee2c904644e h1:Q973S6CcWr1ICZhFI1STFOJ+KUImCl2BaIXm6YppBqI=
git.zhangdeman.cn/zhangdeman/util v0.0.0-20240618042405-6ee2c904644e/go.mod h1:VpPjBlwz8U+OxZuxzHQBv1aEEZ3pStH6bZvT21ADEbI=
github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8= github.com/BurntSushi/toml v1.3.2 h1:o7IhLm0Msx3BaB+n3Ag7L8EVlByGnpq14C4YWiu/gL8=
github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/toml v1.3.2/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ=
github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
github.com/Jeffail/gabs v1.4.0 h1://5fYRRTq1edjfIrQGvdkcd22pkYUrHZ5YC/H2GJVAo= github.com/Jeffail/gabs v1.4.0 h1://5fYRRTq1edjfIrQGvdkcd22pkYUrHZ5YC/H2GJVAo=
github.com/Jeffail/gabs v1.4.0/go.mod h1:6xMvQMK4k33lb7GUUpaAPh6nKMmemQeg5d4gn7/bOXc= github.com/Jeffail/gabs v1.4.0/go.mod h1:6xMvQMK4k33lb7GUUpaAPh6nKMmemQeg5d4gn7/bOXc=
github.com/axgle/mahonia v0.0.0-20180208002826-3358181d7394 h1:OYA+5W64v3OgClL+IrOD63t4i/RW7RqrAVl9LTZ9UqQ= github.com/axgle/mahonia v0.0.0-20180208002826-3358181d7394 h1:OYA+5W64v3OgClL+IrOD63t4i/RW7RqrAVl9LTZ9UqQ=

326
normal.go
View File

@ -7,12 +7,334 @@
// Date : 2021-02-23 10:03 下午 // Date : 2021-02-23 10:03 下午
package easymap package easymap
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"sync"
"git.zhangdeman.cn/zhangdeman/util"
)
// NewNormal 获取map实例 // NewNormal 获取map实例
// //
// Author : go_developer@163.com<白茶清欢> // Author : go_developer@163.com<白茶清欢>
// //
// Date : 10:07 下午 2021/2/23 // Date : 10:07 下午 2021/2/23
func NewNormal() EasyMap { func NewNormal(withLock bool) EasyMap {
em, _ := NewSegment(1) em := &normal{
data: make(map[interface{}]interface{}),
withLock: withLock,
}
if withLock {
em.lock = &sync.RWMutex{}
}
return em 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)
}

View File

@ -7,32 +7,207 @@
// Date : 2021-02-23 10:47 下午 // Date : 2021-02-23 10:47 下午
package easymap package easymap
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"git.zhangdeman.cn/zhangdeman/util"
)
// NewSegment 获取分段map实例 // NewSegment 获取分段map实例
// //
// Author : go_developer@163.com<白茶清欢> // Author : go_developer@163.com<白茶清欢>
// //
// Date : 11:05 下午 2021/2/24 // Date : 11:05 下午 2021/2/24
func NewSegment(segmentCnt int) (EasyMap, error) { func NewSegment(segmentCnt int, withLock bool) (EasyMap, error) {
if segmentCnt <= 0 { if segmentCnt <= 0 {
return nil, segmentError() return nil, segmentError()
} }
em := &segment{ em := &segment{
&common{
normalDataTable: nil,
syncMapDataTable: nil,
dataTableType: normalDataTableType,
segment: segmentCnt, segment: segmentCnt,
lock: nil,
},
} }
em.normalDataTable = make([]map[any]any, segmentCnt) em.dataTable = make([]EasyMap, segmentCnt)
for i := 0; i < segmentCnt; i++ { for i := 0; i < segmentCnt; i++ {
em.normalDataTable[i] = make(map[any]any) em.dataTable[i] = NewNormal(withLock)
} }
em.common.initLock()
return em, nil return em, nil
} }
type segment struct { type segment struct {
*common 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)
} }

View File

@ -7,7 +7,276 @@
// Date : 2021-02-24 2:08 下午 // Date : 2021-02-24 2:08 下午
package easymap package easymap
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"sync"
"git.zhangdeman.cn/zhangdeman/util"
)
func NewSync() EasyMap { func NewSync() EasyMap {
em, _ := NewSegmentSync(1) return &syncMap{}
return em }
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)
} }

View File

@ -8,7 +8,12 @@
package easymap package easymap
import ( import (
"sync" "bytes"
"encoding/json"
"errors"
"fmt"
"git.zhangdeman.cn/zhangdeman/util"
) )
// NewSegmentSync 获取SegmentSync实例 // NewSegmentSync 获取SegmentSync实例
@ -21,22 +26,164 @@ func NewSegmentSync(segment int) (EasyMap, error) {
return nil, segmentError() return nil, segmentError()
} }
ss := &segmentSync{ ss := &segmentSync{
&common{
normalDataTable: nil,
syncMapDataTable: nil,
dataTableType: syncMapDataTableType,
segment: segment, segment: segment,
lock: nil,
},
} }
ss.syncMapDataTable = make([]sync.Map, segment) ss.dataTable = make([]EasyMap, segment)
for i := 0; i < segment; i++ { for i := 0; i < segment; i++ {
ss.syncMapDataTable[i] = sync.Map{} ss.dataTable[i] = NewSync()
} }
ss.initLock()
return ss, nil return ss, nil
} }
type segmentSync struct { type segmentSync struct {
*common 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)
} }