github.com/sandwich-go/boost@v1.3.29/xcontainer/smap/gen_int64_string.go

// Code generated by gotemplate. DO NOT EDIT.

// smap 包提供了一个分片的协程安全的映射
// NewWithSharedCount 返回一个线程安全的映射实例
// New 返回一个线程安全的映射实例
package smap

import (
	"fmt"
	"strconv"
	"sync"
)

//template type Concurrent(KType,VType,KeyHash)

// A thread safe map.
// To avoid lock bottlenecks this map is dived to several (DefaultShardCount) map shards.

var DefaultShardCountInt64String = uint64(32)

type Int64String struct {
	shardedList  []*shardedInt64String
	shardedCount uint64
}

type shardedInt64String struct {
	items map[int64]string
	sync.RWMutex
}

type TupleInt64String struct {
	Key int64
	Val string
}

// NewWithSharedCount 返回协程安全版本
func NewWithSharedCountInt64String(sharedCount uint64) *Int64String {
	p := &Int64String{
		shardedCount: sharedCount,
		shardedList:  make([]*shardedInt64String, sharedCount),
	}
	for i := uint64(0); i < sharedCount; i++ {
		p.shardedList[i] = &shardedInt64String{items: make(map[int64]string)}
	}
	return p
}

// New 返回协程安全版本
func NewInt64String() *Int64String {
	return NewWithSharedCountInt64String(DefaultShardCountInt64String)
}

// GetShard 返回key对应的分片
func (m *Int64String) GetShard(key int64) *shardedInt64String {
	return m.shardedList[KeyToHashInt64(key)%m.shardedCount]
}

// IsEmpty 返回容器是否为空
func (m *Int64String) IsEmpty() bool {
	return m.Count() == 0
}

// Set 设定元素
func (m *Int64String) Set(key int64, value string) {
	shard := m.GetShard(key)
	shard.Lock()
	shard.items[key] = value
	shard.Unlock()
}

// Keys 返回所有的key列表
func (m *Int64String) Keys() []int64 {
	var ret []int64
	for _, shard := range m.shardedList {
		shard.RLock()
		for key := range shard.items {
			ret = append(ret, key)
		}
		shard.RUnlock()
	}
	return ret
}

// GetAll 返回所有元素副本，其中value浅拷贝
func (m *Int64String) GetAll() map[int64]string {
	data := make(map[int64]string)
	for _, shard := range m.shardedList {
		shard.RLock()
		for key, val := range shard.items {
			data[key] = val
		}
		shard.RUnlock()
	}
	return data
}

// Clear 清空元素
func (m *Int64String) Clear() {
	for _, shard := range m.shardedList {
		shard.Lock()
		shard.items = make(map[int64]string)
		shard.Unlock()
	}
}

// ClearWithFunc 清空元素,onClear在对应分片的Lock内执行，执行完毕后对容器做整体clear操作
//
// Note: 不要在onClear对当前容器做读写操作，容易死锁
//
// data.ClearWithFuncLock(func(key string,val string) {
//		data.Get(...) // 死锁
// })
//
func (m *Int64String) ClearWithFuncLock(onClear func(key int64, val string)) {
	for _, shard := range m.shardedList {
		shard.Lock()
		for key, val := range shard.items {
			onClear(key, val)
		}
		shard.items = make(map[int64]string)
		shard.Unlock()
	}
}

// MGet 返回多个元素
func (m *Int64String) MGet(keys ...int64) map[int64]string {
	data := make(map[int64]string)
	for _, key := range keys {
		if val, ok := m.Get(key); ok {
			data[key] = val
		}
	}
	return data
}

// MSet 同时设定多个元素
func (m *Int64String) MSet(data map[int64]string) {
	for key, value := range data {
		m.Set(key, value)
	}
}

// SetNX 如果key不存在，则设定为value, 设定成功则返回true，否则返回false
func (m *Int64String) SetNX(key int64, value string) (isSet bool) {
	shard := m.GetShard(key)
	shard.Lock()
	if _, ok := shard.items[key]; !ok {
		shard.items[key] = value
		isSet = true
	}
	shard.Unlock()
	return isSet
}

// LockFuncWithKey 对key对应的分片加写锁，并用f操作该分片内数据
//
// Note: 不要对f中对容器的该分片做读写操作，可以直接操作shardData数据源
//
//  data.LockFuncWithKey("test",func(shardData map[string]string) {
//     data.Remove("test")      // 当前分片已被加读锁, 死锁
//  })
//
func (m *Int64String) LockFuncWithKey(key int64, f func(shardData map[int64]string)) {
	shard := m.GetShard(key)
	shard.Lock()
	defer shard.Unlock()
	f(shard.items)
}

// RLockFuncWithKey 对key对应的分片加读锁，并用f操作该分片内数据
//
// Note: 不要在f内对容器做写操作，否则会引起死锁，可以直接操作shardData数据源
//
//  data.RLockFuncWithKey("test",func(shardData map[string]string) {
//     data.Remove("test")      // 当前分片已被加读锁, 死锁
//  })
//
func (m *Int64String) RLockFuncWithKey(key int64, f func(shardData map[int64]string)) {
	shard := m.GetShard(key)
	shard.RLock()
	defer shard.RUnlock()
	f(shard.items)
}

// LockFunc 遍历容器分片，f在Lock写锁内执行
//
// Note: 不要在f内对容器做读写操作，否则会引起死锁，可以直接操作shardData数据源
//
//  data.LockFunc(func(shardData map[string]string) {
//     data.Count()             // 当前分片已被加写锁, 死锁
//  })
//
func (m *Int64String) LockFunc(f func(shardData map[int64]string)) {
	for _, shard := range m.shardedList {
		shard.Lock()
		f(shard.items)
		shard.Unlock()
	}
}

// RLockFunc 遍历容器分片，f在RLock读锁内执行
//
// Note: 不要在f内对容器做修改操作，否则会引起死锁，可以直接操作shardData数据源
//
//  data.RLockFunc(func(shardData map[string]string) {
//     data.Remove("test")      // 当前分片已被加读锁, 死锁
//  })
//
func (m *Int64String) RLockFunc(f func(shardData map[int64]string)) {
	for _, shard := range m.shardedList {
		shard.RLock()
		f(shard.items)
		shard.RUnlock()
	}
}

func (m *Int64String) doSetWithLockCheck(key int64, val string) (result string, isSet bool) {
	shard := m.GetShard(key)
	shard.Lock()

	if got, ok := shard.items[key]; ok {
		shard.Unlock()
		return got, false
	}

	shard.items[key] = val
	isSet = true
	result = val
	shard.Unlock()
	return
}

func (m *Int64String) doSetWithLockCheckWithFunc(key int64, f func(key int64) string) (result string, isSet bool) {
	shard := m.GetShard(key)
	shard.Lock()

	if got, ok := shard.items[key]; ok {
		shard.Unlock()
		return got, false
	}

	val := f(key)
	shard.items[key] = val
	isSet = true
	result = val
	shard.Unlock()
	return
}

// GetOrSetFunc 获取或者设定数值，方法f在Lock写锁外执行, 如元素早已存在则返回false,设定成功返回true
func (m *Int64String) GetOrSetFunc(key int64, f func(key int64) string) (result string, isSet bool) {
	if v, ok := m.Get(key); ok {
		return v, false
	}
	return m.doSetWithLockCheck(key, f(key))
}

// GetOrSetFuncLock 获取或者设定数值，方法f在Lock写锁内执行, 如元素早已存在则返回false,设定成功返回true
//
// Note: 不要在f内对容器做操作，否则会死锁
//
//  data.GetOrSetFuncLock(“test”,func(key string)string {
//     data.Count() // 死锁
//  })
//
func (m *Int64String) GetOrSetFuncLock(key int64, f func(key int64) string) (result string, isSet bool) {
	if v, ok := m.Get(key); ok {
		return v, false
	}
	return m.doSetWithLockCheckWithFunc(key, f)
}

// GetOrSet 获取或设定元素, 如元素早已存在则返回false,设定成功返回true
func (m *Int64String) GetOrSet(key int64, val string) (string, bool) {
	if v, ok := m.Get(key); ok {
		return v, false
	}
	return m.doSetWithLockCheck(key, val)
}

// Get 返回key对应的元素，不存在返回false
func (m *Int64String) Get(key int64) (string, bool) {
	shard := m.GetShard(key)
	shard.RLock()
	val, ok := shard.items[key]
	shard.RUnlock()
	return val, ok
}

// Len Count方法别名
func (m *Int64String) Len() int { return m.Count() }

// Size Count方法别名
func (m *Int64String) Size() int { return m.Count() }

// Count 返回容器内元素数量
func (m *Int64String) Count() int {
	count := 0
	for i := uint64(0); i < m.shardedCount; i++ {
		shard := m.shardedList[i]
		shard.RLock()
		count += len(shard.items)
		shard.RUnlock()
	}
	return count
}

// Has 是否存在key对应的元素
func (m *Int64String) Has(key int64) bool {
	shard := m.GetShard(key)
	shard.RLock()
	_, ok := shard.items[key]
	shard.RUnlock()
	return ok
}

// Remove 删除key对应的元素
func (m *Int64String) Remove(key int64) {
	shard := m.GetShard(key)
	shard.Lock()
	delete(shard.items, key)
	shard.Unlock()
}

// GetAndRemove 返回key对应的元素并将其由容器中删除，如果元素不存在则返回false
func (m *Int64String) GetAndRemove(key int64) (string, bool) {
	shard := m.GetShard(key)
	shard.Lock()
	val, ok := shard.items[key]
	delete(shard.items, key)
	shard.Unlock()
	return val, ok
}

// Iter 迭代当前容器内所有元素，使用无缓冲chan
//
// Note: 不要在迭代过程中对当前容器作修改操作(申请写锁)，容易会产生死锁
//
//  for v:= data.Iter() {
//		data.Remove(v.Key) // 尝试删除元素申请分片Lock,但是Iter内部的迭代协程对分片做了RLock，导致死锁
//  }
//
func (m *Int64String) Iter() <-chan TupleInt64String {
	ch := make(chan TupleInt64String)
	go func() {
		// Foreach shard.
		for _, shard := range m.shardedList {
			shard.RLock()
			// Foreach key, value pair.
			for key, val := range shard.items {
				ch <- TupleInt64String{key, val}
			}
			shard.RUnlock()
		}
		close(ch)
	}()
	return ch
}

// IterBuffered 迭代当前容器内所有元素，使用有缓冲chan，缓冲区大小等于容器大小,迭代过程中操作容器是安全的
func (m *Int64String) IterBuffered() <-chan TupleInt64String {
	ch := make(chan TupleInt64String, m.Count())
	go func() {
		// Foreach shard.
		for _, shard := range m.shardedList {
			// Foreach key, value pair.
			shard.RLock()
			for key, val := range shard.items {
				ch <- TupleInt64String{key, val}
			}
			shard.RUnlock()
		}
		close(ch)
	}()
	return ch
}

//template format
var __formatKTypeToInt64String = func(i interface{}) int64 {
	switch ii := i.(type) {
	case int:
		return int64(ii)
	case int8:
		return int64(ii)
	case int16:
		return int64(ii)
	case int32:
		return int64(ii)
	case int64:
		return int64(ii)
	case uint:
		return int64(ii)
	case uint8:
		return int64(ii)
	case uint16:
		return int64(ii)
	case uint32:
		return int64(ii)
	case uint64:
		return int64(ii)
	case float32:
		return int64(ii)
	case float64:
		return int64(ii)
	case string:
		iv, err := strconv.ParseInt(ii, 10, 64)
		if err != nil {
			panic(err)
		}
		return int64(iv)
	default:
		panic("unknown type")
	}
}

//template format
var __formatVTypeToInt64String = func(i interface{}) string {
	switch ii := i.(type) {
	case string:
		return ii
	default:
		return fmt.Sprintf("%d", i)
	}
}