github.com/sandwich-go/boost@v1.3.29/xcontainer/sset/gen_int64.go

// Code generated by gotemplate. DO NOT EDIT.

// sset 包提供了多种类型的集合
// 可以产生一个带读写锁的线程安全的SyncSet，也可以产生一个非线程安全的SyncSet
// New 产生非协程安全的版本
// NewSync 产生协程安全的版本
package sset

import (
	"strconv"
	"sync"
)

//template type SyncSet(VType)

type Int64 struct {
	mu   *localRWMutexVTypeInt64
	data map[int64]struct{}
}

// New 创建非协程安全版本
func NewInt64() *Int64 { return newWithSafeInt64(false) }

// NewSync 创建协程安全版本
func NewSyncInt64() *Int64 { return newWithSafeInt64(true) }

func newWithSafeInt64(safe bool) *Int64 {
	return &Int64{data: make(map[int64]struct{}), mu: newLocalRWMutexVTypeInt64(safe)}
}

// Iterator 遍历
func (set *Int64) Iterator(f func(v int64) bool) {
	set.mu.RLock()
	defer set.mu.RUnlock()
	for k := range set.data {
		if !f(k) {
			break
		}
	}
}

// Add 添加元素
func (set *Int64) Add(items ...int64) {
	set.mu.Lock()
	if set.data == nil {
		set.data = make(map[int64]struct{})
	}
	for _, v := range items {
		set.data[v] = struct{}{}
	}
	set.mu.Unlock()
}

// AddIfNotExist 如果元素不存在则添加，如添加成功则返回true
func (set *Int64) AddIfNotExist(item int64) (addOK bool) {
	if !set.Contains(item) {
		set.mu.Lock()
		defer set.mu.Unlock()
		if set.data == nil {
			set.data = make(map[int64]struct{})
		}
		if _, ok := set.data[item]; !ok {
			set.data[item] = struct{}{}
			return true
		}
	}
	return false
}

// AddIfNotExistFunc 如果元素不存在且f返回true则添加，如添加成功则返回true
// f函数运行在lock之外
func (set *Int64) AddIfNotExistFunc(item int64, f func() bool) bool {
	if !set.Contains(item) {
		if f() {
			set.mu.Lock()
			defer set.mu.Unlock()
			if set.data == nil {
				set.data = make(map[int64]struct{})
			}
			if _, ok := set.data[item]; !ok {
				set.data[item] = struct{}{}
				return true
			}
		}
	}
	return false
}

// AddIfNotExistFuncLock 如果元素不存在且f返回true则添加，如添加成功则返回true
// f函数运行在lock之内
func (set *Int64) AddIfNotExistFuncLock(item int64, f func() bool) bool {
	if !set.Contains(item) {
		set.mu.Lock()
		defer set.mu.Unlock()
		if set.data == nil {
			set.data = make(map[int64]struct{})
		}
		if f() {
			if _, ok := set.data[item]; !ok {
				set.data[item] = struct{}{}
				return true
			}
		}
	}
	return false
}

// Contains 是否存在元素
func (set *Int64) Contains(item int64) bool {
	var ok bool
	set.mu.RLock()
	if set.data != nil {
		_, ok = set.data[item]
	}
	set.mu.RUnlock()
	return ok
}

// Remove 移除指定元素
func (set *Int64) Remove(item int64) {
	set.mu.Lock()
	if set.data != nil {
		delete(set.data, item)
	}
	set.mu.Unlock()
}

// Size 返回长度
func (set *Int64) Size() int {
	set.mu.RLock()
	l := len(set.data)
	set.mu.RUnlock()
	return l
}

// Clear 清理元素
func (set *Int64) Clear() {
	set.mu.Lock()
	set.data = make(map[int64]struct{})
	set.mu.Unlock()
}

// Slice 返回元素slice
func (set *Int64) Slice() []int64 {
	set.mu.RLock()
	var i = 0
	var ret = make([]int64, len(set.data))
	for item := range set.data {
		ret[i] = item
		i++
	}
	set.mu.RUnlock()
	return ret
}

// LockFunc 锁住当前set调用方法f
func (set *Int64) LockFunc(f func(m map[int64]struct{})) {
	set.mu.Lock()
	defer set.mu.Unlock()
	f(set.data)
}

// RLockFunc 读锁住当前set调用方法f
func (set *Int64) RLockFunc(f func(m map[int64]struct{})) {
	set.mu.RLock()
	defer set.mu.RUnlock()
	f(set.data)
}

// Equal 是否相等
func (set *Int64) Equal(other *Int64) bool {
	if set == other {
		return true
	}
	set.mu.RLock()
	defer set.mu.RUnlock()
	other.mu.RLock()
	defer other.mu.RUnlock()
	if len(set.data) != len(other.data) {
		return false
	}
	for key := range set.data {
		if _, ok := other.data[key]; !ok {
			return false
		}
	}
	return true
}

// Merge 合并set，返回当前set
func (set *Int64) Merge(others ...*Int64) *Int64 {
	set.mu.Lock()
	defer set.mu.Unlock()
	for _, other := range others {
		if set != other {
			other.mu.RLock()
		}
		for k, v := range other.data {
			set.data[k] = v
		}
		if set != other {
			other.mu.RUnlock()
		}
	}
	return set
}

// Walk 对每个元素作用f方法
func (set *Int64) Walk(f func(item int64) int64) *Int64 {
	set.mu.Lock()
	defer set.mu.Unlock()
	m := make(map[int64]struct{}, len(set.data))
	for k, v := range set.data {
		m[f(k)] = v
	}
	set.data = m
	return set
}

type localRWMutexVTypeInt64 struct {
	*sync.RWMutex
}

func newLocalRWMutexVTypeInt64(safe bool) *localRWMutexVTypeInt64 {
	mu := localRWMutexVTypeInt64{}
	if safe {
		mu.RWMutex = new(sync.RWMutex)
	}
	return &mu
}

func (mu *localRWMutexVTypeInt64) IsSafe() bool {
	return mu.RWMutex != nil
}

func (mu *localRWMutexVTypeInt64) Lock() {
	if mu.RWMutex != nil {
		mu.RWMutex.Lock()
	}
}

func (mu *localRWMutexVTypeInt64) Unlock() {
	if mu.RWMutex != nil {
		mu.RWMutex.Unlock()
	}
}

func (mu *localRWMutexVTypeInt64) RLock() {
	if mu.RWMutex != nil {
		mu.RWMutex.RLock()
	}
}

func (mu *localRWMutexVTypeInt64) RUnlock() {
	if mu.RWMutex != nil {
		mu.RWMutex.RUnlock()
	}
}

//template format
var __formatToInt64 = 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")
	}
}