mirror of
https://github.com/lxzan/gws
synced 2026-04-22 15:47:14 +08:00
lxzan
144 lines
3.6 KiB
Go
144 lines
3.6 KiB
Go
package gws
|
|
|
|
import (
|
|
"sync"
|
|
)
|
|
|
|
// SessionStorage 会话存储
|
|
type SessionStorage interface {
|
|
// Len 返回存储中的键值对数量
|
|
// Returns the number of key-value pairs in the storage
|
|
Len() int
|
|
|
|
// Load 根据键获取值，如果键存在则返回值和 true，否则返回 nil 和 false
|
|
// retrieves the value for a given key. If the key exists, it returns the value and true; otherwise, it returns nil and false
|
|
Load(key string) (value any, exist bool)
|
|
|
|
// Delete 根据键删除存储中的键值对
|
|
// removes the key-value pair from the storage for a given key
|
|
Delete(key string)
|
|
|
|
// Store 存储键值对
|
|
// saves the key-value pair in the storage
|
|
Store(key string, value any)
|
|
|
|
// Range 遍历
|
|
// 如果函数返回 false，遍历将提前终止.
|
|
// If the function returns false, the iteration stops early.
|
|
Range(f func(key string, value any) bool)
|
|
}
|
|
|
|
// newSmap 创建并返回一个新的 smap 实例
|
|
// creates and returns a new smap instance
|
|
func newSmap() *smap {
|
|
return &smap{data: make(map[string]any)}
|
|
}
|
|
|
|
// smap 基于 map 的会话存储实现
|
|
// map-based implementation of the session storage
|
|
type smap struct {
|
|
sync.Mutex
|
|
data map[string]any
|
|
}
|
|
|
|
// Len 返回存储中的键值对数量
|
|
// returns the number of key-value pairs in the storage
|
|
func (c *smap) Len() int {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
return len(c.data)
|
|
}
|
|
|
|
// Load 根据键获取值，如果键存在则返回值和 true，否则返回 nil 和 false
|
|
// retrieves the value for a given key. If the key exists, it returns the value and true; otherwise, it returns nil and false
|
|
func (c *smap) Load(key string) (value any, exist bool) {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
value, exist = c.data[key]
|
|
return
|
|
}
|
|
|
|
// Delete 根据键删除存储中的键值对
|
|
// removes the key-value pair from the storage for a given key
|
|
func (c *smap) Delete(key string) {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
delete(c.data, key)
|
|
}
|
|
|
|
// Store 存储键值对
|
|
// saves the key-value pair in the storage
|
|
func (c *smap) Store(key string, value any) {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
c.data[key] = value
|
|
}
|
|
|
|
// Range 遍历
|
|
func (c *smap) Range(f func(key string, value any) bool) {
|
|
c.Lock()
|
|
defer c.Unlock()
|
|
|
|
for k, v := range c.data {
|
|
if !f(k, v) {
|
|
return
|
|
}
|
|
}
|
|
}
|
|
|
|
// ConcurrentMap 并发安全的映射结构
|
|
// concurrency-safe map structure
|
|
type ConcurrentMap[K comparable, V any] struct {
|
|
m sync.Map
|
|
}
|
|
|
|
// NewConcurrentMap 创建一个新的并发安全映射
|
|
// creates a new concurrency-safe map
|
|
func NewConcurrentMap[K comparable, V any]() *ConcurrentMap[K, V] {
|
|
return &ConcurrentMap[K, V]{}
|
|
}
|
|
|
|
// Len 返回映射中的元素数量
|
|
// Len returns the number of elements in the map
|
|
func (c *ConcurrentMap[K, V]) Len() int {
|
|
var length int
|
|
c.m.Range(func(_, _ any) bool {
|
|
length++
|
|
return true
|
|
})
|
|
return length
|
|
}
|
|
|
|
// Load 返回映射中键对应的值，如果不存在则返回 nil
|
|
// returns the value stored in the map for a key, or nil if no value is present
|
|
// ok 结果表示是否在映射中找到了值
|
|
// The ok result indicates whether the value was found in the map
|
|
func (c *ConcurrentMap[K, V]) Load(key K) (value V, ok bool) {
|
|
v, ok := c.m.Load(key)
|
|
if !ok {
|
|
return value, false
|
|
}
|
|
return v.(V), true
|
|
}
|
|
|
|
// Delete 删除键对应的值
|
|
// Delete deletes the value for a key
|
|
func (c *ConcurrentMap[K, V]) Delete(key K) {
|
|
c.m.Delete(key)
|
|
}
|
|
|
|
// Store 设置键对应的值
|
|
// sets the value for a key
|
|
func (c *ConcurrentMap[K, V]) Store(key K, value V) {
|
|
c.m.Store(key, value)
|
|
}
|
|
|
|
// Range 遍历
|
|
// 如果 f 返回 false，遍历停止
|
|
// If f returns false, range stops the iteration
|
|
func (c *ConcurrentMap[K, V]) Range(f func(key K, value V) bool) {
|
|
c.m.Range(func(k, v any) bool {
|
|
return f(k.(K), v.(V))
|
|
})
|
|
}
|