mirror of
https://gitee.com/johng/gf
synced 2026-06-06 02:25:47 +08:00
feat(container/gset): add generic set feature (#4492)
Add generic set featrue: TSet[T] --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Co-authored-by: hailaz <739476267@qq.com>
This commit is contained in:
Hunk Zhu
@ -8,18 +8,15 @@
|
||||
package gset
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"sync"
|
||||
|
||||
"github.com/gogf/gf/v2/internal/json"
|
||||
"github.com/gogf/gf/v2/internal/rwmutex"
|
||||
"github.com/gogf/gf/v2/text/gstr"
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
)
|
||||
|
||||
// Set is consisted of any items.
|
||||
type Set struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[any]struct{}
|
||||
*TSet[any]
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
// New create and returns a new set, which contains un-repeated items.
|
||||
@ -33,44 +30,38 @@ func New(safe ...bool) *Set {
|
||||
// Also see New.
|
||||
func NewSet(safe ...bool) *Set {
|
||||
return &Set{
|
||||
data: make(map[any]struct{}),
|
||||
mu: rwmutex.Create(safe...),
|
||||
TSet: NewTSet[any](safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// NewFrom returns a new set from `items`.
|
||||
// Parameter `items` can be either a variable of any type, or a slice.
|
||||
func NewFrom(items any, safe ...bool) *Set {
|
||||
m := make(map[any]struct{})
|
||||
for _, v := range gconv.Interfaces(items) {
|
||||
m[v] = struct{}{}
|
||||
}
|
||||
return &Set{
|
||||
data: m,
|
||||
mu: rwmutex.Create(safe...),
|
||||
TSet: NewTSetFrom[any](gconv.Interfaces(items), safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// lazyInit lazily initializes the set.
|
||||
func (a *Set) lazyInit() {
|
||||
a.once.Do(func() {
|
||||
if a.TSet == nil {
|
||||
a.TSet = NewTSet[any]()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Iterator iterates the set readonly with given callback function `f`,
|
||||
// if `f` returns true then continue iterating; or false to stop.
|
||||
func (set *Set) Iterator(f func(v any) bool) {
|
||||
for _, k := range set.Slice() {
|
||||
if !f(k) {
|
||||
break
|
||||
}
|
||||
}
|
||||
set.lazyInit()
|
||||
set.TSet.Iterator(f)
|
||||
}
|
||||
|
||||
// Add adds one or multiple items to the set.
|
||||
func (set *Set) Add(items ...any) {
|
||||
set.mu.Lock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
for _, v := range items {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Add(items...)
|
||||
}
|
||||
|
||||
// AddIfNotExist checks whether item exists in the set,
|
||||
@ -79,21 +70,8 @@ func (set *Set) Add(items ...any) {
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false.
|
||||
func (set *Set) AddIfNotExist(item any) bool {
|
||||
if item == nil {
|
||||
return false
|
||||
}
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExist(item)
|
||||
}
|
||||
|
||||
// AddIfNotExistFunc checks whether item exists in the set,
|
||||
@ -103,23 +81,8 @@ func (set *Set) AddIfNotExist(item any) bool {
|
||||
// Note that, if `item` is nil, it does nothing and returns false. The function `f`
|
||||
// is executed without writing lock.
|
||||
func (set *Set) AddIfNotExistFunc(item any, f func() bool) bool {
|
||||
if item == nil {
|
||||
return false
|
||||
}
|
||||
if !set.Contains(item) {
|
||||
if f() {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExistFunc(item, f)
|
||||
}
|
||||
|
||||
// AddIfNotExistFuncLock checks whether item exists in the set,
|
||||
@ -129,95 +92,44 @@ func (set *Set) AddIfNotExistFunc(item any, f func() bool) bool {
|
||||
// Note that, if `item` is nil, it does nothing and returns false. The function `f`
|
||||
// is executed within writing lock.
|
||||
func (set *Set) AddIfNotExistFuncLock(item any, f func() bool) bool {
|
||||
if item == nil {
|
||||
return false
|
||||
}
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
if f() {
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExistFuncLock(item, f)
|
||||
}
|
||||
|
||||
// Contains checks whether the set contains `item`.
|
||||
func (set *Set) Contains(item any) bool {
|
||||
var ok bool
|
||||
set.mu.RLock()
|
||||
if set.data != nil {
|
||||
_, ok = set.data[item]
|
||||
}
|
||||
set.mu.RUnlock()
|
||||
return ok
|
||||
set.lazyInit()
|
||||
return set.TSet.Contains(item)
|
||||
}
|
||||
|
||||
// Remove deletes `item` from set.
|
||||
func (set *Set) Remove(item any) {
|
||||
set.mu.Lock()
|
||||
if set.data != nil {
|
||||
delete(set.data, item)
|
||||
}
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Remove(item)
|
||||
}
|
||||
|
||||
// Size returns the size of the set.
|
||||
func (set *Set) Size() int {
|
||||
set.mu.RLock()
|
||||
l := len(set.data)
|
||||
set.mu.RUnlock()
|
||||
return l
|
||||
set.lazyInit()
|
||||
return set.TSet.Size()
|
||||
}
|
||||
|
||||
// Clear deletes all items of the set.
|
||||
func (set *Set) Clear() {
|
||||
set.mu.Lock()
|
||||
set.data = make(map[any]struct{})
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Clear()
|
||||
}
|
||||
|
||||
// Slice returns all items of the set as slice.
|
||||
func (set *Set) Slice() []any {
|
||||
set.mu.RLock()
|
||||
var (
|
||||
i = 0
|
||||
ret = make([]any, len(set.data))
|
||||
)
|
||||
for item := range set.data {
|
||||
ret[i] = item
|
||||
i++
|
||||
}
|
||||
set.mu.RUnlock()
|
||||
return ret
|
||||
set.lazyInit()
|
||||
return set.TSet.Slice()
|
||||
}
|
||||
|
||||
// Join joins items with a string `glue`.
|
||||
func (set *Set) Join(glue string) string {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if len(set.data) == 0 {
|
||||
return ""
|
||||
}
|
||||
var (
|
||||
l = len(set.data)
|
||||
i = 0
|
||||
buffer = bytes.NewBuffer(nil)
|
||||
)
|
||||
for k := range set.data {
|
||||
buffer.WriteString(gconv.String(k))
|
||||
if i != l-1 {
|
||||
buffer.WriteString(glue)
|
||||
}
|
||||
i++
|
||||
}
|
||||
return buffer.String()
|
||||
set.lazyInit()
|
||||
return set.TSet.Join(glue)
|
||||
}
|
||||
|
||||
// String returns items as a string, which implements like json.Marshal does.
|
||||
@ -225,63 +137,27 @@ func (set *Set) String() string {
|
||||
if set == nil {
|
||||
return ""
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
var (
|
||||
s string
|
||||
l = len(set.data)
|
||||
i = 0
|
||||
buffer = bytes.NewBuffer(nil)
|
||||
)
|
||||
buffer.WriteByte('[')
|
||||
for k := range set.data {
|
||||
s = gconv.String(k)
|
||||
if gstr.IsNumeric(s) {
|
||||
buffer.WriteString(s)
|
||||
} else {
|
||||
buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
|
||||
}
|
||||
if i != l-1 {
|
||||
buffer.WriteByte(',')
|
||||
}
|
||||
i++
|
||||
}
|
||||
buffer.WriteByte(']')
|
||||
return buffer.String()
|
||||
set.lazyInit()
|
||||
return set.TSet.String()
|
||||
}
|
||||
|
||||
// LockFunc locks writing with callback function `f`.
|
||||
func (set *Set) LockFunc(f func(m map[any]struct{})) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
f(set.data)
|
||||
set.lazyInit()
|
||||
set.TSet.LockFunc(f)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with callback function `f`.
|
||||
func (set *Set) RLockFunc(f func(m map[any]struct{})) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
f(set.data)
|
||||
set.lazyInit()
|
||||
set.TSet.RLockFunc(f)
|
||||
}
|
||||
|
||||
// Equal checks whether the two sets equal.
|
||||
func (set *Set) Equal(other *Set) 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
|
||||
set.lazyInit()
|
||||
other.lazyInit()
|
||||
return set.TSet.Equal(other.TSet)
|
||||
}
|
||||
|
||||
// IsSubsetOf checks whether the current set is a sub-set of `other`.
|
||||
@ -289,85 +165,40 @@ func (set *Set) IsSubsetOf(other *Set) bool {
|
||||
if set == other {
|
||||
return true
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
other.mu.RLock()
|
||||
defer other.mu.RUnlock()
|
||||
for key := range set.data {
|
||||
if _, ok := other.data[key]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
|
||||
set.lazyInit()
|
||||
other.lazyInit()
|
||||
|
||||
return set.TSet.IsSubsetOf(other.TSet)
|
||||
}
|
||||
|
||||
// Union returns a new set which is the union of `set` and `others`.
|
||||
// Which means, all the items in `newSet` are in `set` or in `others`.
|
||||
func (set *Set) Union(others ...*Set) (newSet *Set) {
|
||||
newSet = NewSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
if set != other {
|
||||
for k, v := range other.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
}
|
||||
set.lazyInit()
|
||||
|
||||
return
|
||||
return &Set{
|
||||
TSet: set.TSet.Union(set.toTSetSlice(others)...),
|
||||
}
|
||||
}
|
||||
|
||||
// Diff returns a new set which is the difference set from `set` to `others`.
|
||||
// Which means, all the items in `newSet` are in `set` but not in `others`.
|
||||
func (set *Set) Diff(others ...*Set) (newSet *Set) {
|
||||
newSet = NewSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set == other {
|
||||
continue
|
||||
}
|
||||
other.mu.RLock()
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
other.mu.RUnlock()
|
||||
set.lazyInit()
|
||||
|
||||
return &Set{
|
||||
TSet: set.TSet.Diff(set.toTSetSlice(others)...),
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Intersect returns a new set which is the intersection from `set` to `others`.
|
||||
// Which means, all the items in `newSet` are in `set` and also in `others`.
|
||||
func (set *Set) Intersect(others ...*Set) (newSet *Set) {
|
||||
newSet = NewSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
set.lazyInit()
|
||||
return &Set{
|
||||
TSet: set.TSet.Intersect(set.toTSetSlice(others)...),
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Complement returns a new set which is the complement from `set` to `full`.
|
||||
@ -376,36 +207,22 @@ func (set *Set) Intersect(others ...*Set) (newSet *Set) {
|
||||
// It returns the difference between `full` and `set`
|
||||
// if the given set `full` is not the full set of `set`.
|
||||
func (set *Set) Complement(full *Set) (newSet *Set) {
|
||||
newSet = NewSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if set != full {
|
||||
full.mu.RLock()
|
||||
defer full.mu.RUnlock()
|
||||
}
|
||||
for k, v := range full.data {
|
||||
if _, ok := set.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
set.lazyInit()
|
||||
if full == nil {
|
||||
return &Set{
|
||||
TSet: NewTSet[any](true),
|
||||
}
|
||||
}
|
||||
return
|
||||
full.lazyInit()
|
||||
return &Set{
|
||||
TSet: set.TSet.Complement(full.TSet),
|
||||
}
|
||||
}
|
||||
|
||||
// Merge adds items from `others` sets into `set`.
|
||||
func (set *Set) Merge(others ...*Set) *Set {
|
||||
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()
|
||||
}
|
||||
}
|
||||
set.lazyInit()
|
||||
set.TSet.Merge(set.toTSetSlice(others)...)
|
||||
return set
|
||||
}
|
||||
|
||||
@ -413,101 +230,46 @@ func (set *Set) Merge(others ...*Set) *Set {
|
||||
// Note: The items should be converted to int type,
|
||||
// or you'd get a result that you unexpected.
|
||||
func (set *Set) Sum() (sum int) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for k := range set.data {
|
||||
sum += gconv.Int(k)
|
||||
}
|
||||
return
|
||||
set.lazyInit()
|
||||
return set.TSet.Sum()
|
||||
}
|
||||
|
||||
// Pop randomly pops an item from set.
|
||||
func (set *Set) Pop() any {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
return k
|
||||
}
|
||||
return nil
|
||||
set.lazyInit()
|
||||
return set.TSet.Pop()
|
||||
}
|
||||
|
||||
// Pops randomly pops `size` items from set.
|
||||
// It returns all items if size == -1.
|
||||
func (set *Set) Pops(size int) []any {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if size > len(set.data) || size == -1 {
|
||||
size = len(set.data)
|
||||
}
|
||||
if size <= 0 {
|
||||
return nil
|
||||
}
|
||||
index := 0
|
||||
array := make([]any, size)
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
array[index] = k
|
||||
index++
|
||||
if index == size {
|
||||
break
|
||||
}
|
||||
}
|
||||
return array
|
||||
set.lazyInit()
|
||||
return set.TSet.Pops(size)
|
||||
}
|
||||
|
||||
// Walk applies a user supplied function `f` to every item of set.
|
||||
func (set *Set) Walk(f func(item any) any) *Set {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
m := make(map[any]struct{}, len(set.data))
|
||||
for k, v := range set.data {
|
||||
m[f(k)] = v
|
||||
}
|
||||
set.data = m
|
||||
set.lazyInit()
|
||||
set.TSet.Walk(f)
|
||||
return set
|
||||
}
|
||||
|
||||
// MarshalJSON implements the interface MarshalJSON for json.Marshal.
|
||||
func (set Set) MarshalJSON() ([]byte, error) {
|
||||
return json.Marshal(set.Slice())
|
||||
set.lazyInit()
|
||||
return set.TSet.MarshalJSON()
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
|
||||
func (set *Set) UnmarshalJSON(b []byte) error {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
var array []any
|
||||
if err := json.UnmarshalUseNumber(b, &array); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return nil
|
||||
set.lazyInit()
|
||||
return set.TSet.UnmarshalJSON(b)
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for set.
|
||||
func (set *Set) UnmarshalValue(value any) (err error) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[any]struct{})
|
||||
}
|
||||
var array []any
|
||||
switch value.(type) {
|
||||
case string, []byte:
|
||||
err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
|
||||
default:
|
||||
array = gconv.SliceAny(value)
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return
|
||||
set.lazyInit()
|
||||
return set.TSet.UnmarshalValue(value)
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
@ -515,11 +277,21 @@ func (set *Set) DeepCopy() any {
|
||||
if set == nil {
|
||||
return nil
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
data := make([]any, 0)
|
||||
for k := range set.data {
|
||||
data = append(data, k)
|
||||
set.lazyInit()
|
||||
return &Set{
|
||||
TSet: set.TSet.DeepCopy().(*TSet[any]),
|
||||
}
|
||||
return NewFrom(data, set.mu.IsSafe())
|
||||
}
|
||||
|
||||
// toTSetSlice converts []*Set to []*TSet[any]
|
||||
func (set *Set) toTSetSlice(sets []*Set) (tSets []*TSet[any]) {
|
||||
tSets = make([]*TSet[any], len(sets))
|
||||
for i, v := range sets {
|
||||
if v == nil {
|
||||
continue
|
||||
}
|
||||
v.lazyInit()
|
||||
tSets[i] = v.TSet
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
@ -8,17 +8,13 @@
|
||||
package gset
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
|
||||
"github.com/gogf/gf/v2/internal/json"
|
||||
"github.com/gogf/gf/v2/internal/rwmutex"
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// IntSet is consisted of int items.
|
||||
type IntSet struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[int]struct{}
|
||||
*TSet[int]
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
// NewIntSet create and returns a new set, which contains un-repeated items.
|
||||
@ -26,43 +22,37 @@ type IntSet struct {
|
||||
// which is false in default.
|
||||
func NewIntSet(safe ...bool) *IntSet {
|
||||
return &IntSet{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: make(map[int]struct{}),
|
||||
TSet: NewTSet[int](safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// NewIntSetFrom returns a new set from `items`.
|
||||
func NewIntSetFrom(items []int, safe ...bool) *IntSet {
|
||||
m := make(map[int]struct{})
|
||||
for _, v := range items {
|
||||
m[v] = struct{}{}
|
||||
}
|
||||
return &IntSet{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: m,
|
||||
TSet: NewTSetFrom(items, safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// lazyInit lazily initializes the set.
|
||||
func (a *IntSet) lazyInit() {
|
||||
a.once.Do(func() {
|
||||
if a.TSet == nil {
|
||||
a.TSet = NewTSet[int]()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Iterator iterates the set readonly with given callback function `f`,
|
||||
// if `f` returns true then continue iterating; or false to stop.
|
||||
func (set *IntSet) Iterator(f func(v int) bool) {
|
||||
for _, k := range set.Slice() {
|
||||
if !f(k) {
|
||||
break
|
||||
}
|
||||
}
|
||||
set.lazyInit()
|
||||
set.TSet.Iterator(f)
|
||||
}
|
||||
|
||||
// Add adds one or multiple items to the set.
|
||||
func (set *IntSet) Add(item ...int) {
|
||||
set.mu.Lock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[int]struct{})
|
||||
}
|
||||
for _, v := range item {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Add(item...)
|
||||
}
|
||||
|
||||
// AddIfNotExist checks whether item exists in the set,
|
||||
@ -71,18 +61,8 @@ func (set *IntSet) Add(item ...int) {
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false.
|
||||
func (set *IntSet) AddIfNotExist(item int) bool {
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[int]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExist(item)
|
||||
}
|
||||
|
||||
// AddIfNotExistFunc checks whether item exists in the set,
|
||||
@ -91,20 +71,8 @@ func (set *IntSet) AddIfNotExist(item int) bool {
|
||||
//
|
||||
// Note that, the function `f` is executed without writing lock.
|
||||
func (set *IntSet) AddIfNotExistFunc(item int, 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[int]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExistFunc(item, f)
|
||||
}
|
||||
|
||||
// AddIfNotExistFuncLock checks whether item exists in the set,
|
||||
@ -113,92 +81,44 @@ func (set *IntSet) AddIfNotExistFunc(item int, f func() bool) bool {
|
||||
//
|
||||
// Note that, the function `f` is executed without writing lock.
|
||||
func (set *IntSet) AddIfNotExistFuncLock(item int, f func() bool) bool {
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[int]struct{})
|
||||
}
|
||||
if f() {
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExistFuncLock(item, f)
|
||||
}
|
||||
|
||||
// Contains checks whether the set contains `item`.
|
||||
func (set *IntSet) Contains(item int) bool {
|
||||
var ok bool
|
||||
set.mu.RLock()
|
||||
if set.data != nil {
|
||||
_, ok = set.data[item]
|
||||
}
|
||||
set.mu.RUnlock()
|
||||
return ok
|
||||
set.lazyInit()
|
||||
return set.TSet.Contains(item)
|
||||
}
|
||||
|
||||
// Remove deletes `item` from set.
|
||||
func (set *IntSet) Remove(item int) {
|
||||
set.mu.Lock()
|
||||
if set.data != nil {
|
||||
delete(set.data, item)
|
||||
}
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Remove(item)
|
||||
}
|
||||
|
||||
// Size returns the size of the set.
|
||||
func (set *IntSet) Size() int {
|
||||
set.mu.RLock()
|
||||
l := len(set.data)
|
||||
set.mu.RUnlock()
|
||||
return l
|
||||
set.lazyInit()
|
||||
return set.TSet.Size()
|
||||
}
|
||||
|
||||
// Clear deletes all items of the set.
|
||||
func (set *IntSet) Clear() {
|
||||
set.mu.Lock()
|
||||
set.data = make(map[int]struct{})
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Clear()
|
||||
}
|
||||
|
||||
// Slice returns the an of items of the set as slice.
|
||||
func (set *IntSet) Slice() []int {
|
||||
set.mu.RLock()
|
||||
var (
|
||||
i = 0
|
||||
ret = make([]int, len(set.data))
|
||||
)
|
||||
for k := range set.data {
|
||||
ret[i] = k
|
||||
i++
|
||||
}
|
||||
set.mu.RUnlock()
|
||||
return ret
|
||||
set.lazyInit()
|
||||
return set.TSet.Slice()
|
||||
}
|
||||
|
||||
// Join joins items with a string `glue`.
|
||||
func (set *IntSet) Join(glue string) string {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if len(set.data) == 0 {
|
||||
return ""
|
||||
}
|
||||
var (
|
||||
l = len(set.data)
|
||||
i = 0
|
||||
buffer = bytes.NewBuffer(nil)
|
||||
)
|
||||
for k := range set.data {
|
||||
buffer.WriteString(gconv.String(k))
|
||||
if i != l-1 {
|
||||
buffer.WriteString(glue)
|
||||
}
|
||||
i++
|
||||
}
|
||||
return buffer.String()
|
||||
set.lazyInit()
|
||||
return set.TSet.Join(glue)
|
||||
}
|
||||
|
||||
// String returns items as a string, which implements like json.Marshal does.
|
||||
@ -206,41 +126,27 @@ func (set *IntSet) String() string {
|
||||
if set == nil {
|
||||
return ""
|
||||
}
|
||||
return "[" + set.Join(",") + "]"
|
||||
set.lazyInit()
|
||||
return set.TSet.String()
|
||||
}
|
||||
|
||||
// LockFunc locks writing with callback function `f`.
|
||||
func (set *IntSet) LockFunc(f func(m map[int]struct{})) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
f(set.data)
|
||||
set.lazyInit()
|
||||
set.TSet.LockFunc(f)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with callback function `f`.
|
||||
func (set *IntSet) RLockFunc(f func(m map[int]struct{})) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
f(set.data)
|
||||
set.lazyInit()
|
||||
set.TSet.RLockFunc(f)
|
||||
}
|
||||
|
||||
// Equal checks whether the two sets equal.
|
||||
func (set *IntSet) Equal(other *IntSet) 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
|
||||
set.lazyInit()
|
||||
other.lazyInit()
|
||||
return set.TSet.Equal(other.TSet)
|
||||
}
|
||||
|
||||
// IsSubsetOf checks whether the current set is a sub-set of `other`.
|
||||
@ -248,85 +154,38 @@ func (set *IntSet) IsSubsetOf(other *IntSet) bool {
|
||||
if set == other {
|
||||
return true
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
other.mu.RLock()
|
||||
defer other.mu.RUnlock()
|
||||
for key := range set.data {
|
||||
if _, ok := other.data[key]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
|
||||
set.lazyInit()
|
||||
other.lazyInit()
|
||||
|
||||
return set.TSet.IsSubsetOf(other.TSet)
|
||||
}
|
||||
|
||||
// Union returns a new set which is the union of `set` and `other`.
|
||||
// Which means, all the items in `newSet` are in `set` or in `other`.
|
||||
func (set *IntSet) Union(others ...*IntSet) (newSet *IntSet) {
|
||||
newSet = NewIntSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
if set != other {
|
||||
for k, v := range other.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
set.lazyInit()
|
||||
return &IntSet{
|
||||
TSet: set.TSet.Union(set.toTSetSlice(others)...),
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Diff returns a new set which is the difference set from `set` to `other`.
|
||||
// Which means, all the items in `newSet` are in `set` but not in `other`.
|
||||
func (set *IntSet) Diff(others ...*IntSet) (newSet *IntSet) {
|
||||
newSet = NewIntSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set == other {
|
||||
continue
|
||||
}
|
||||
other.mu.RLock()
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
other.mu.RUnlock()
|
||||
set.lazyInit()
|
||||
return &IntSet{
|
||||
TSet: set.TSet.Diff(set.toTSetSlice(others)...),
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Intersect returns a new set which is the intersection from `set` to `other`.
|
||||
// Which means, all the items in `newSet` are in `set` and also in `other`.
|
||||
func (set *IntSet) Intersect(others ...*IntSet) (newSet *IntSet) {
|
||||
newSet = NewIntSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
set.lazyInit()
|
||||
return &IntSet{
|
||||
TSet: set.TSet.Intersect(set.toTSetSlice(others)...),
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Complement returns a new set which is the complement from `set` to `full`.
|
||||
@ -335,36 +194,22 @@ func (set *IntSet) Intersect(others ...*IntSet) (newSet *IntSet) {
|
||||
// It returns the difference between `full` and `set`
|
||||
// if the given set `full` is not the full set of `set`.
|
||||
func (set *IntSet) Complement(full *IntSet) (newSet *IntSet) {
|
||||
newSet = NewIntSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if set != full {
|
||||
full.mu.RLock()
|
||||
defer full.mu.RUnlock()
|
||||
}
|
||||
for k, v := range full.data {
|
||||
if _, ok := set.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
set.lazyInit()
|
||||
if full == nil {
|
||||
return &IntSet{
|
||||
TSet: NewTSet[int](),
|
||||
}
|
||||
}
|
||||
return
|
||||
full.lazyInit()
|
||||
return &IntSet{
|
||||
TSet: set.TSet.Complement(full.TSet),
|
||||
}
|
||||
}
|
||||
|
||||
// Merge adds items from `others` sets into `set`.
|
||||
func (set *IntSet) Merge(others ...*IntSet) *IntSet {
|
||||
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()
|
||||
}
|
||||
}
|
||||
set.lazyInit()
|
||||
set.TSet.Merge(set.toTSetSlice(others)...)
|
||||
return set
|
||||
}
|
||||
|
||||
@ -372,101 +217,46 @@ func (set *IntSet) Merge(others ...*IntSet) *IntSet {
|
||||
// Note: The items should be converted to int type,
|
||||
// or you'd get a result that you unexpected.
|
||||
func (set *IntSet) Sum() (sum int) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for k := range set.data {
|
||||
sum += k
|
||||
}
|
||||
return
|
||||
set.lazyInit()
|
||||
return set.TSet.Sum()
|
||||
}
|
||||
|
||||
// Pop randomly pops an item from set.
|
||||
func (set *IntSet) Pop() int {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
return k
|
||||
}
|
||||
return 0
|
||||
set.lazyInit()
|
||||
return set.TSet.Pop()
|
||||
}
|
||||
|
||||
// Pops randomly pops `size` items from set.
|
||||
// It returns all items if size == -1.
|
||||
func (set *IntSet) Pops(size int) []int {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if size > len(set.data) || size == -1 {
|
||||
size = len(set.data)
|
||||
}
|
||||
if size <= 0 {
|
||||
return nil
|
||||
}
|
||||
index := 0
|
||||
array := make([]int, size)
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
array[index] = k
|
||||
index++
|
||||
if index == size {
|
||||
break
|
||||
}
|
||||
}
|
||||
return array
|
||||
set.lazyInit()
|
||||
return set.TSet.Pops(size)
|
||||
}
|
||||
|
||||
// Walk applies a user supplied function `f` to every item of set.
|
||||
func (set *IntSet) Walk(f func(item int) int) *IntSet {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
m := make(map[int]struct{}, len(set.data))
|
||||
for k, v := range set.data {
|
||||
m[f(k)] = v
|
||||
}
|
||||
set.data = m
|
||||
set.lazyInit()
|
||||
set.TSet.Walk(f)
|
||||
return set
|
||||
}
|
||||
|
||||
// MarshalJSON implements the interface MarshalJSON for json.Marshal.
|
||||
func (set IntSet) MarshalJSON() ([]byte, error) {
|
||||
return json.Marshal(set.Slice())
|
||||
set.lazyInit()
|
||||
return set.TSet.MarshalJSON()
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
|
||||
func (set *IntSet) UnmarshalJSON(b []byte) error {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[int]struct{})
|
||||
}
|
||||
var array []int
|
||||
if err := json.UnmarshalUseNumber(b, &array); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return nil
|
||||
set.lazyInit()
|
||||
return set.TSet.UnmarshalJSON(b)
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for set.
|
||||
func (set *IntSet) UnmarshalValue(value any) (err error) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[int]struct{})
|
||||
}
|
||||
var array []int
|
||||
switch value.(type) {
|
||||
case string, []byte:
|
||||
err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
|
||||
default:
|
||||
array = gconv.SliceInt(value)
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return
|
||||
set.lazyInit()
|
||||
return set.TSet.UnmarshalValue(value)
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
@ -474,15 +264,21 @@ func (set *IntSet) DeepCopy() any {
|
||||
if set == nil {
|
||||
return nil
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
var (
|
||||
slice = make([]int, len(set.data))
|
||||
index = 0
|
||||
)
|
||||
for k := range set.data {
|
||||
slice[index] = k
|
||||
index++
|
||||
set.lazyInit()
|
||||
return &IntSet{
|
||||
TSet: set.TSet.DeepCopy().(*TSet[int]),
|
||||
}
|
||||
return NewIntSetFrom(slice, set.mu.IsSafe())
|
||||
}
|
||||
|
||||
// toTSetSlice converts []*IntSet to []*TSet[int]
|
||||
func (set *IntSet) toTSetSlice(sets []*IntSet) (tSets []*TSet[int]) {
|
||||
tSets = make([]*TSet[int], len(sets))
|
||||
for i, v := range sets {
|
||||
if v == nil {
|
||||
continue
|
||||
}
|
||||
v.lazyInit()
|
||||
tSets[i] = v.TSet
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
@ -8,19 +8,14 @@
|
||||
package gset
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"strings"
|
||||
|
||||
"github.com/gogf/gf/v2/internal/json"
|
||||
"github.com/gogf/gf/v2/internal/rwmutex"
|
||||
"github.com/gogf/gf/v2/text/gstr"
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
"sync"
|
||||
)
|
||||
|
||||
// StrSet is consisted of string items.
|
||||
type StrSet struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[string]struct{}
|
||||
*TSet[string]
|
||||
once sync.Once
|
||||
}
|
||||
|
||||
// NewStrSet create and returns a new set, which contains un-repeated items.
|
||||
@ -28,61 +23,45 @@ type StrSet struct {
|
||||
// which is false in default.
|
||||
func NewStrSet(safe ...bool) *StrSet {
|
||||
return &StrSet{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: make(map[string]struct{}),
|
||||
TSet: NewTSet[string](safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// NewStrSetFrom returns a new set from `items`.
|
||||
func NewStrSetFrom(items []string, safe ...bool) *StrSet {
|
||||
m := make(map[string]struct{})
|
||||
for _, v := range items {
|
||||
m[v] = struct{}{}
|
||||
}
|
||||
return &StrSet{
|
||||
mu: rwmutex.Create(safe...),
|
||||
data: m,
|
||||
TSet: NewTSetFrom(items, safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// lazyInit lazily initializes the set.
|
||||
func (a *StrSet) lazyInit() {
|
||||
a.once.Do(func() {
|
||||
if a.TSet == nil {
|
||||
a.TSet = NewTSet[string]()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
// Iterator iterates the set readonly with given callback function `f`,
|
||||
// if `f` returns true then continue iterating; or false to stop.
|
||||
func (set *StrSet) Iterator(f func(v string) bool) {
|
||||
for _, k := range set.Slice() {
|
||||
if !f(k) {
|
||||
break
|
||||
}
|
||||
}
|
||||
set.lazyInit()
|
||||
set.TSet.Iterator(f)
|
||||
}
|
||||
|
||||
// Add adds one or multiple items to the set.
|
||||
func (set *StrSet) Add(item ...string) {
|
||||
set.mu.Lock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[string]struct{})
|
||||
}
|
||||
for _, v := range item {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Add(item...)
|
||||
}
|
||||
|
||||
// AddIfNotExist checks whether item exists in the set,
|
||||
// it adds the item to set and returns true if it does not exist in the set,
|
||||
// or else it does nothing and returns false.
|
||||
func (set *StrSet) AddIfNotExist(item string) bool {
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[string]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExist(item)
|
||||
}
|
||||
|
||||
// AddIfNotExistFunc checks whether item exists in the set,
|
||||
@ -91,20 +70,8 @@ func (set *StrSet) AddIfNotExist(item string) bool {
|
||||
//
|
||||
// Note that, the function `f` is executed without writing lock.
|
||||
func (set *StrSet) AddIfNotExistFunc(item string, 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[string]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExistFunc(item, f)
|
||||
}
|
||||
|
||||
// AddIfNotExistFuncLock checks whether item exists in the set,
|
||||
@ -113,36 +80,20 @@ func (set *StrSet) AddIfNotExistFunc(item string, f func() bool) bool {
|
||||
//
|
||||
// Note that, the function `f` is executed without writing lock.
|
||||
func (set *StrSet) AddIfNotExistFuncLock(item string, f func() bool) bool {
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[string]struct{})
|
||||
}
|
||||
if f() {
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
set.lazyInit()
|
||||
return set.TSet.AddIfNotExistFuncLock(item, f)
|
||||
}
|
||||
|
||||
// Contains checks whether the set contains `item`.
|
||||
func (set *StrSet) Contains(item string) bool {
|
||||
var ok bool
|
||||
set.mu.RLock()
|
||||
if set.data != nil {
|
||||
_, ok = set.data[item]
|
||||
}
|
||||
set.mu.RUnlock()
|
||||
return ok
|
||||
set.lazyInit()
|
||||
return set.TSet.Contains(item)
|
||||
}
|
||||
|
||||
// ContainsI checks whether a value exists in the set with case-insensitively.
|
||||
// Note that it internally iterates the whole set to do the comparison with case-insensitively.
|
||||
func (set *StrSet) ContainsI(item string) bool {
|
||||
set.lazyInit()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for k := range set.data {
|
||||
@ -155,64 +106,32 @@ func (set *StrSet) ContainsI(item string) bool {
|
||||
|
||||
// Remove deletes `item` from set.
|
||||
func (set *StrSet) Remove(item string) {
|
||||
set.mu.Lock()
|
||||
if set.data != nil {
|
||||
delete(set.data, item)
|
||||
}
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Remove(item)
|
||||
}
|
||||
|
||||
// Size returns the size of the set.
|
||||
func (set *StrSet) Size() int {
|
||||
set.mu.RLock()
|
||||
l := len(set.data)
|
||||
set.mu.RUnlock()
|
||||
return l
|
||||
set.lazyInit()
|
||||
return set.TSet.Size()
|
||||
}
|
||||
|
||||
// Clear deletes all items of the set.
|
||||
func (set *StrSet) Clear() {
|
||||
set.mu.Lock()
|
||||
set.data = make(map[string]struct{})
|
||||
set.mu.Unlock()
|
||||
set.lazyInit()
|
||||
set.TSet.Clear()
|
||||
}
|
||||
|
||||
// Slice returns the an of items of the set as slice.
|
||||
func (set *StrSet) Slice() []string {
|
||||
set.mu.RLock()
|
||||
var (
|
||||
i = 0
|
||||
ret = make([]string, len(set.data))
|
||||
)
|
||||
for item := range set.data {
|
||||
ret[i] = item
|
||||
i++
|
||||
}
|
||||
|
||||
set.mu.RUnlock()
|
||||
return ret
|
||||
set.lazyInit()
|
||||
return set.TSet.Slice()
|
||||
}
|
||||
|
||||
// Join joins items with a string `glue`.
|
||||
func (set *StrSet) Join(glue string) string {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if len(set.data) == 0 {
|
||||
return ""
|
||||
}
|
||||
var (
|
||||
l = len(set.data)
|
||||
i = 0
|
||||
buffer = bytes.NewBuffer(nil)
|
||||
)
|
||||
for k := range set.data {
|
||||
buffer.WriteString(k)
|
||||
if i != l-1 {
|
||||
buffer.WriteString(glue)
|
||||
}
|
||||
i++
|
||||
}
|
||||
return buffer.String()
|
||||
set.lazyInit()
|
||||
return set.TSet.Join(glue)
|
||||
}
|
||||
|
||||
// String returns items as a string, which implements like json.Marshal does.
|
||||
@ -220,57 +139,27 @@ func (set *StrSet) String() string {
|
||||
if set == nil {
|
||||
return ""
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
var (
|
||||
l = len(set.data)
|
||||
i = 0
|
||||
buffer = bytes.NewBuffer(nil)
|
||||
)
|
||||
buffer.WriteByte('[')
|
||||
for k := range set.data {
|
||||
buffer.WriteString(`"` + gstr.QuoteMeta(k, `"\`) + `"`)
|
||||
if i != l-1 {
|
||||
buffer.WriteByte(',')
|
||||
}
|
||||
i++
|
||||
}
|
||||
buffer.WriteByte(']')
|
||||
return buffer.String()
|
||||
set.lazyInit()
|
||||
return set.TSet.String()
|
||||
}
|
||||
|
||||
// LockFunc locks writing with callback function `f`.
|
||||
func (set *StrSet) LockFunc(f func(m map[string]struct{})) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
f(set.data)
|
||||
set.lazyInit()
|
||||
set.TSet.LockFunc(f)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with callback function `f`.
|
||||
func (set *StrSet) RLockFunc(f func(m map[string]struct{})) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
f(set.data)
|
||||
set.lazyInit()
|
||||
set.TSet.RLockFunc(f)
|
||||
}
|
||||
|
||||
// Equal checks whether the two sets equal.
|
||||
func (set *StrSet) Equal(other *StrSet) 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
|
||||
set.lazyInit()
|
||||
other.lazyInit()
|
||||
return set.TSet.Equal(other.TSet)
|
||||
}
|
||||
|
||||
// IsSubsetOf checks whether the current set is a sub-set of `other`.
|
||||
@ -278,85 +167,38 @@ func (set *StrSet) IsSubsetOf(other *StrSet) bool {
|
||||
if set == other {
|
||||
return true
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
other.mu.RLock()
|
||||
defer other.mu.RUnlock()
|
||||
for key := range set.data {
|
||||
if _, ok := other.data[key]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
|
||||
set.lazyInit()
|
||||
other.lazyInit()
|
||||
|
||||
return set.TSet.IsSubsetOf(other.TSet)
|
||||
}
|
||||
|
||||
// Union returns a new set which is the union of `set` and `other`.
|
||||
// Which means, all the items in `newSet` are in `set` or in `other`.
|
||||
func (set *StrSet) Union(others ...*StrSet) (newSet *StrSet) {
|
||||
newSet = NewStrSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
if set != other {
|
||||
for k, v := range other.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
set.lazyInit()
|
||||
return &StrSet{
|
||||
TSet: set.TSet.Union(set.toTSetSlice(others)...),
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Diff returns a new set which is the difference set from `set` to `other`.
|
||||
// Which means, all the items in `newSet` are in `set` but not in `other`.
|
||||
func (set *StrSet) Diff(others ...*StrSet) (newSet *StrSet) {
|
||||
newSet = NewStrSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set == other {
|
||||
continue
|
||||
}
|
||||
other.mu.RLock()
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
other.mu.RUnlock()
|
||||
set.lazyInit()
|
||||
return &StrSet{
|
||||
TSet: set.TSet.Diff(set.toTSetSlice(others)...),
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Intersect returns a new set which is the intersection from `set` to `other`.
|
||||
// Which means, all the items in `newSet` are in `set` and also in `other`.
|
||||
func (set *StrSet) Intersect(others ...*StrSet) (newSet *StrSet) {
|
||||
newSet = NewStrSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
set.lazyInit()
|
||||
return &StrSet{
|
||||
TSet: set.TSet.Intersect(set.toTSetSlice(others)...),
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Complement returns a new set which is the complement from `set` to `full`.
|
||||
@ -365,36 +207,22 @@ func (set *StrSet) Intersect(others ...*StrSet) (newSet *StrSet) {
|
||||
// It returns the difference between `full` and `set`
|
||||
// if the given set `full` is not the full set of `set`.
|
||||
func (set *StrSet) Complement(full *StrSet) (newSet *StrSet) {
|
||||
newSet = NewStrSet()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if set != full {
|
||||
full.mu.RLock()
|
||||
defer full.mu.RUnlock()
|
||||
}
|
||||
for k, v := range full.data {
|
||||
if _, ok := set.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
set.lazyInit()
|
||||
if full == nil {
|
||||
return &StrSet{
|
||||
TSet: NewTSet[string](),
|
||||
}
|
||||
}
|
||||
return
|
||||
full.lazyInit()
|
||||
return &StrSet{
|
||||
TSet: set.TSet.Complement(full.TSet),
|
||||
}
|
||||
}
|
||||
|
||||
// Merge adds items from `others` sets into `set`.
|
||||
func (set *StrSet) Merge(others ...*StrSet) *StrSet {
|
||||
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()
|
||||
}
|
||||
}
|
||||
set.lazyInit()
|
||||
set.TSet.Merge(set.toTSetSlice(others)...)
|
||||
return set
|
||||
}
|
||||
|
||||
@ -402,101 +230,46 @@ func (set *StrSet) Merge(others ...*StrSet) *StrSet {
|
||||
// Note: The items should be converted to int type,
|
||||
// or you'd get a result that you unexpected.
|
||||
func (set *StrSet) Sum() (sum int) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for k := range set.data {
|
||||
sum += gconv.Int(k)
|
||||
}
|
||||
return
|
||||
set.lazyInit()
|
||||
return set.TSet.Sum()
|
||||
}
|
||||
|
||||
// Pop randomly pops an item from set.
|
||||
func (set *StrSet) Pop() string {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
return k
|
||||
}
|
||||
return ""
|
||||
set.lazyInit()
|
||||
return set.TSet.Pop()
|
||||
}
|
||||
|
||||
// Pops randomly pops `size` items from set.
|
||||
// It returns all items if size == -1.
|
||||
func (set *StrSet) Pops(size int) []string {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if size > len(set.data) || size == -1 {
|
||||
size = len(set.data)
|
||||
}
|
||||
if size <= 0 {
|
||||
return nil
|
||||
}
|
||||
index := 0
|
||||
array := make([]string, size)
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
array[index] = k
|
||||
index++
|
||||
if index == size {
|
||||
break
|
||||
}
|
||||
}
|
||||
return array
|
||||
set.lazyInit()
|
||||
return set.TSet.Pops(size)
|
||||
}
|
||||
|
||||
// Walk applies a user supplied function `f` to every item of set.
|
||||
func (set *StrSet) Walk(f func(item string) string) *StrSet {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
m := make(map[string]struct{}, len(set.data))
|
||||
for k, v := range set.data {
|
||||
m[f(k)] = v
|
||||
}
|
||||
set.data = m
|
||||
set.lazyInit()
|
||||
set.TSet.Walk(f)
|
||||
return set
|
||||
}
|
||||
|
||||
// MarshalJSON implements the interface MarshalJSON for json.Marshal.
|
||||
func (set StrSet) MarshalJSON() ([]byte, error) {
|
||||
return json.Marshal(set.Slice())
|
||||
set.lazyInit()
|
||||
return set.TSet.MarshalJSON()
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
|
||||
func (set *StrSet) UnmarshalJSON(b []byte) error {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[string]struct{})
|
||||
}
|
||||
var array []string
|
||||
if err := json.UnmarshalUseNumber(b, &array); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return nil
|
||||
set.lazyInit()
|
||||
return set.TSet.UnmarshalJSON(b)
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for set.
|
||||
func (set *StrSet) UnmarshalValue(value any) (err error) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[string]struct{})
|
||||
}
|
||||
var array []string
|
||||
switch value.(type) {
|
||||
case string, []byte:
|
||||
err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
|
||||
default:
|
||||
array = gconv.SliceStr(value)
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return
|
||||
set.lazyInit()
|
||||
return set.TSet.UnmarshalValue(value)
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
@ -504,15 +277,21 @@ func (set *StrSet) DeepCopy() any {
|
||||
if set == nil {
|
||||
return nil
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
var (
|
||||
slice = make([]string, len(set.data))
|
||||
index = 0
|
||||
)
|
||||
for k := range set.data {
|
||||
slice[index] = k
|
||||
index++
|
||||
set.lazyInit()
|
||||
return &StrSet{
|
||||
TSet: set.TSet.DeepCopy().(*TSet[string]),
|
||||
}
|
||||
return NewStrSetFrom(slice, set.mu.IsSafe())
|
||||
}
|
||||
|
||||
// toTSetSlice converts []*StrSet to []*TSet[string]
|
||||
func (set *StrSet) toTSetSlice(sets []*StrSet) (tSets []*TSet[string]) {
|
||||
tSets = make([]*TSet[string], len(sets))
|
||||
for i, v := range sets {
|
||||
if v == nil {
|
||||
continue
|
||||
}
|
||||
v.lazyInit()
|
||||
tSets[i] = v.TSet
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
531
container/gset/gset_t_set.go
Normal file
531
container/gset/gset_t_set.go
Normal file
@ -0,0 +1,531 @@
|
||||
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
||||
//
|
||||
// This Source Code Form is subject to the terms of the MIT License.
|
||||
// If a copy of the MIT was not distributed with this file,
|
||||
// You can obtain one at https://github.com/gogf/gf.
|
||||
|
||||
package gset
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
|
||||
"github.com/gogf/gf/v2/internal/json"
|
||||
"github.com/gogf/gf/v2/internal/rwmutex"
|
||||
"github.com/gogf/gf/v2/text/gstr"
|
||||
"github.com/gogf/gf/v2/util/gconv"
|
||||
)
|
||||
|
||||
// TSet[T] is consisted of any items.
|
||||
type TSet[T comparable] struct {
|
||||
mu rwmutex.RWMutex
|
||||
data map[T]struct{}
|
||||
}
|
||||
|
||||
// NewTSet creates and returns a new set, which contains un-repeated items.
|
||||
// Also see New.
|
||||
func NewTSet[T comparable](safe ...bool) *TSet[T] {
|
||||
return &TSet[T]{
|
||||
data: make(map[T]struct{}),
|
||||
mu: rwmutex.Create(safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// NewTSetFrom returns a new set from `items`.
|
||||
// `items` - A slice of type T.
|
||||
func NewTSetFrom[T comparable](items []T, safe ...bool) *TSet[T] {
|
||||
m := make(map[T]struct{})
|
||||
for _, v := range items {
|
||||
m[v] = struct{}{}
|
||||
}
|
||||
return &TSet[T]{
|
||||
data: m,
|
||||
mu: rwmutex.Create(safe...),
|
||||
}
|
||||
}
|
||||
|
||||
// Iterator iterates the set readonly with given callback function `f`,
|
||||
// if `f` returns true then continue iterating; or false to stop.
|
||||
func (set *TSet[T]) Iterator(f func(v T) bool) {
|
||||
for _, k := range set.Slice() {
|
||||
if !f(k) {
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Add adds one or multiple items to the set.
|
||||
func (set *TSet[T]) Add(items ...T) {
|
||||
set.mu.Lock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[T]struct{})
|
||||
}
|
||||
for _, v := range items {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
set.mu.Unlock()
|
||||
}
|
||||
|
||||
// AddIfNotExist checks whether item exists in the set,
|
||||
// it adds the item to set and returns true if it does not exists in the set,
|
||||
// or else it does nothing and returns false.
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false.
|
||||
func (set *TSet[T]) AddIfNotExist(item T) bool {
|
||||
if any(item) == nil {
|
||||
return false
|
||||
}
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[T]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AddIfNotExistFunc checks whether item exists in the set,
|
||||
// it adds the item to set and returns true if it does not exist in the set and
|
||||
// function `f` returns true, or else it does nothing and returns false.
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false. The function `f`
|
||||
// is executed without writing lock.
|
||||
func (set *TSet[T]) AddIfNotExistFunc(item T, f func() bool) bool {
|
||||
if any(item) == nil {
|
||||
return false
|
||||
}
|
||||
if !set.Contains(item) {
|
||||
if f() {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[T]struct{})
|
||||
}
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// AddIfNotExistFuncLock checks whether item exists in the set,
|
||||
// it adds the item to set and returns true if it does not exists in the set and
|
||||
// function `f` returns true, or else it does nothing and returns false.
|
||||
//
|
||||
// Note that, if `item` is nil, it does nothing and returns false. The function `f`
|
||||
// is executed within writing lock.
|
||||
func (set *TSet[T]) AddIfNotExistFuncLock(item T, f func() bool) bool {
|
||||
if any(item) == nil {
|
||||
return false
|
||||
}
|
||||
if !set.Contains(item) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[T]struct{})
|
||||
}
|
||||
if f() {
|
||||
if _, ok := set.data[item]; !ok {
|
||||
set.data[item] = struct{}{}
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// Contains checks whether the set contains `item`.
|
||||
func (set *TSet[T]) Contains(item T) bool {
|
||||
var ok bool
|
||||
set.mu.RLock()
|
||||
if set.data != nil {
|
||||
_, ok = set.data[item]
|
||||
}
|
||||
set.mu.RUnlock()
|
||||
return ok
|
||||
}
|
||||
|
||||
// Remove deletes `item` from set.
|
||||
func (set *TSet[T]) Remove(item T) {
|
||||
set.mu.Lock()
|
||||
if set.data != nil {
|
||||
delete(set.data, item)
|
||||
}
|
||||
set.mu.Unlock()
|
||||
}
|
||||
|
||||
// Size returns the size of the set.
|
||||
func (set *TSet[T]) Size() int {
|
||||
set.mu.RLock()
|
||||
l := len(set.data)
|
||||
set.mu.RUnlock()
|
||||
return l
|
||||
}
|
||||
|
||||
// Clear deletes all items of the set.
|
||||
func (set *TSet[T]) Clear() {
|
||||
set.mu.Lock()
|
||||
set.data = make(map[T]struct{})
|
||||
set.mu.Unlock()
|
||||
}
|
||||
|
||||
// Slice returns all items of the set as slice.
|
||||
func (set *TSet[T]) Slice() []T {
|
||||
set.mu.RLock()
|
||||
var (
|
||||
i = 0
|
||||
ret = make([]T, len(set.data))
|
||||
)
|
||||
for item := range set.data {
|
||||
ret[i] = item
|
||||
i++
|
||||
}
|
||||
set.mu.RUnlock()
|
||||
return ret
|
||||
}
|
||||
|
||||
// Join joins items with a string `glue`.
|
||||
func (set *TSet[T]) Join(glue string) string {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if len(set.data) == 0 {
|
||||
return ""
|
||||
}
|
||||
var (
|
||||
l = len(set.data)
|
||||
i = 0
|
||||
buffer = bytes.NewBuffer(nil)
|
||||
)
|
||||
for k := range set.data {
|
||||
buffer.WriteString(gconv.String(k))
|
||||
if i != l-1 {
|
||||
buffer.WriteString(glue)
|
||||
}
|
||||
i++
|
||||
}
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// String returns items as a string, which implements like json.Marshal does.
|
||||
func (set *TSet[T]) String() string {
|
||||
if set == nil {
|
||||
return ""
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
var (
|
||||
s string
|
||||
l = len(set.data)
|
||||
i = 0
|
||||
buffer = bytes.NewBuffer(nil)
|
||||
)
|
||||
buffer.WriteByte('[')
|
||||
for k := range set.data {
|
||||
s = gconv.String(k)
|
||||
if gstr.IsNumeric(s) {
|
||||
buffer.WriteString(s)
|
||||
} else {
|
||||
buffer.WriteString(`"` + gstr.QuoteMeta(s, `"\`) + `"`)
|
||||
}
|
||||
if i != l-1 {
|
||||
buffer.WriteByte(',')
|
||||
}
|
||||
i++
|
||||
}
|
||||
buffer.WriteByte(']')
|
||||
return buffer.String()
|
||||
}
|
||||
|
||||
// LockFunc locks writing with callback function `f`.
|
||||
func (set *TSet[T]) LockFunc(f func(m map[T]struct{})) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
f(set.data)
|
||||
}
|
||||
|
||||
// RLockFunc locks reading with callback function `f`.
|
||||
func (set *TSet[T]) RLockFunc(f func(m map[T]struct{})) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
f(set.data)
|
||||
}
|
||||
|
||||
// Equal checks whether the two sets equal.
|
||||
func (set *TSet[T]) Equal(other *TSet[T]) 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
|
||||
}
|
||||
|
||||
// IsSubsetOf checks whether the current set is a sub-set of `other`.
|
||||
func (set *TSet[T]) IsSubsetOf(other *TSet[T]) bool {
|
||||
if set == other {
|
||||
return true
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
other.mu.RLock()
|
||||
defer other.mu.RUnlock()
|
||||
for key := range set.data {
|
||||
if _, ok := other.data[key]; !ok {
|
||||
return false
|
||||
}
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
// Union returns a new set which is the union of `set` and `others`.
|
||||
// Which means, all the items in `newSet` are in `set` or in `others`.
|
||||
func (set *TSet[T]) Union(others ...*TSet[T]) (newSet *TSet[T]) {
|
||||
newSet = NewTSet[T]()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if other == nil {
|
||||
continue
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
if set != other {
|
||||
for k, v := range other.data {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
|
||||
// Diff returns a new set which is the difference set from `set` to `others`.
|
||||
// Which means, all the items in `newSet` are in `set` but not in `others`.
|
||||
func (set *TSet[T]) Diff(others ...*TSet[T]) (newSet *TSet[T]) {
|
||||
newSet = NewTSet[T]()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if other == nil {
|
||||
continue
|
||||
}
|
||||
if set == other {
|
||||
continue
|
||||
}
|
||||
other.mu.RLock()
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Intersect returns a new set which is the intersection from `set` to `others`.
|
||||
// Which means, all the items in `newSet` are in `set` and also in `others`.
|
||||
func (set *TSet[T]) Intersect(others ...*TSet[T]) (newSet *TSet[T]) {
|
||||
newSet = NewTSet[T]()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for _, other := range others {
|
||||
if other == nil {
|
||||
continue
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range set.data {
|
||||
if _, ok := other.data[k]; ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Complement returns a new set which is the complement from `set` to `full`.
|
||||
// Which means, all the items in `newSet` are in `full` and not in `set`.
|
||||
//
|
||||
// It returns the difference between `full` and `set`
|
||||
// if the given set `full` is not the full set of `set`.
|
||||
func (set *TSet[T]) Complement(full *TSet[T]) (newSet *TSet[T]) {
|
||||
newSet = NewTSet[T]()
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
if set != full {
|
||||
full.mu.RLock()
|
||||
defer full.mu.RUnlock()
|
||||
}
|
||||
for k, v := range full.data {
|
||||
if _, ok := set.data[k]; !ok {
|
||||
newSet.data[k] = v
|
||||
}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Merge adds items from `others` sets into `set`.
|
||||
func (set *TSet[T]) Merge(others ...*TSet[T]) *TSet[T] {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
for _, other := range others {
|
||||
if other == nil {
|
||||
continue
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RLock()
|
||||
}
|
||||
for k, v := range other.data {
|
||||
set.data[k] = v
|
||||
}
|
||||
if set != other {
|
||||
other.mu.RUnlock()
|
||||
}
|
||||
}
|
||||
return set
|
||||
}
|
||||
|
||||
// Sum sums items.
|
||||
// Note: The items should be converted to int type,
|
||||
// or you'd get a result that you unexpected.
|
||||
func (set *TSet[T]) Sum() (sum int) {
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
for k := range set.data {
|
||||
sum += gconv.Int(k)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Pop randomly pops an item from set.
|
||||
func (set *TSet[T]) Pop() (item T) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
return k
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// Pops randomly pops `size` items from set.
|
||||
// It returns all items if size == -1.
|
||||
func (set *TSet[T]) Pops(size int) []T {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if size > len(set.data) || size == -1 {
|
||||
size = len(set.data)
|
||||
}
|
||||
if size <= 0 {
|
||||
return nil
|
||||
}
|
||||
index := 0
|
||||
array := make([]T, size)
|
||||
for k := range set.data {
|
||||
delete(set.data, k)
|
||||
array[index] = k
|
||||
index++
|
||||
if index == size {
|
||||
break
|
||||
}
|
||||
}
|
||||
return array
|
||||
}
|
||||
|
||||
// Walk applies a user supplied function `f` to every item of set.
|
||||
func (set *TSet[T]) Walk(f func(item T) T) *TSet[T] {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
m := make(map[T]struct{}, len(set.data))
|
||||
for k, v := range set.data {
|
||||
m[f(k)] = v
|
||||
}
|
||||
set.data = m
|
||||
return set
|
||||
}
|
||||
|
||||
// MarshalJSON implements the interface MarshalJSON for json.Marshal.
|
||||
func (set TSet[T]) MarshalJSON() ([]byte, error) {
|
||||
return json.Marshal(set.Slice())
|
||||
}
|
||||
|
||||
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
|
||||
func (set *TSet[T]) UnmarshalJSON(b []byte) error {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[T]struct{})
|
||||
}
|
||||
var array []T
|
||||
if err := json.UnmarshalUseNumber(b, &array); err != nil {
|
||||
return err
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// UnmarshalValue is an interface implement which sets any type of value for set.
|
||||
func (set *TSet[T]) UnmarshalValue(value any) (err error) {
|
||||
set.mu.Lock()
|
||||
defer set.mu.Unlock()
|
||||
if set.data == nil {
|
||||
set.data = make(map[T]struct{})
|
||||
}
|
||||
var array []T
|
||||
switch value.(type) {
|
||||
case string, []byte:
|
||||
err = json.UnmarshalUseNumber(gconv.Bytes(value), &array)
|
||||
default:
|
||||
if err = gconv.Scan(value, &array); err != nil {
|
||||
return
|
||||
}
|
||||
}
|
||||
for _, v := range array {
|
||||
set.data[v] = struct{}{}
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
// DeepCopy implements interface for deep copy of current type.
|
||||
func (set *TSet[T]) DeepCopy() any {
|
||||
if set == nil {
|
||||
return nil
|
||||
}
|
||||
set.mu.RLock()
|
||||
defer set.mu.RUnlock()
|
||||
data := make([]T, 0)
|
||||
for k := range set.data {
|
||||
data = append(data, k)
|
||||
}
|
||||
return NewTSetFrom[T](data, set.mu.IsSafe())
|
||||
}
|
||||
@ -187,6 +187,19 @@ func TestSet_Union(t *testing.T) {
|
||||
t.Assert(s3.Contains(3), true)
|
||||
t.Assert(s3.Contains(4), true)
|
||||
})
|
||||
|
||||
// Test with nil element in slice
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewSet()
|
||||
s2 := gset.NewSet()
|
||||
s1.Add(1, 2)
|
||||
s2.Add(3, 4)
|
||||
s3 := s1.Union(s2, nil)
|
||||
t.Assert(s3.Contains(1), true)
|
||||
t.Assert(s3.Contains(2), true)
|
||||
t.Assert(s3.Contains(3), true)
|
||||
t.Assert(s3.Contains(4), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestSet_Diff(t *testing.T) {
|
||||
@ -236,6 +249,14 @@ func TestSet_Complement(t *testing.T) {
|
||||
t.Assert(s3.Contains(4), true)
|
||||
t.Assert(s3.Contains(5), true)
|
||||
})
|
||||
|
||||
// Test with nil full set
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewSet()
|
||||
s1.Add(1, 2, 3)
|
||||
s3 := s1.Complement(nil)
|
||||
t.Assert(s3.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestNewFrom(t *testing.T) {
|
||||
|
||||
@ -167,6 +167,19 @@ func TestIntSet_Union(t *testing.T) {
|
||||
t.Assert(s3.Contains(3), true)
|
||||
t.Assert(s3.Contains(4), true)
|
||||
})
|
||||
|
||||
// Test with nil element in slice
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewIntSet()
|
||||
s2 := gset.NewIntSet()
|
||||
s1.Add(1, 2)
|
||||
s2.Add(3, 4)
|
||||
s3 := s1.Union(s2, nil)
|
||||
t.Assert(s3.Contains(1), true)
|
||||
t.Assert(s3.Contains(2), true)
|
||||
t.Assert(s3.Contains(3), true)
|
||||
t.Assert(s3.Contains(4), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestIntSet_Diff(t *testing.T) {
|
||||
@ -216,6 +229,14 @@ func TestIntSet_Complement(t *testing.T) {
|
||||
t.Assert(s3.Contains(4), true)
|
||||
t.Assert(s3.Contains(5), true)
|
||||
})
|
||||
|
||||
// Test with nil full set
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewIntSet()
|
||||
s1.Add(1, 2, 3)
|
||||
s3 := s1.Complement(nil)
|
||||
t.Assert(s3.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestIntSet_Size(t *testing.T) {
|
||||
|
||||
@ -178,6 +178,19 @@ func TestStrSet_Union(t *testing.T) {
|
||||
t.Assert(s3.Contains("3"), true)
|
||||
t.Assert(s3.Contains("4"), true)
|
||||
})
|
||||
|
||||
// Test with nil element in slice
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewStrSet()
|
||||
s2 := gset.NewStrSet()
|
||||
s1.Add("1", "2")
|
||||
s2.Add("3", "4")
|
||||
s3 := s1.Union(s2, nil)
|
||||
t.Assert(s3.Contains("1"), true)
|
||||
t.Assert(s3.Contains("2"), true)
|
||||
t.Assert(s3.Contains("3"), true)
|
||||
t.Assert(s3.Contains("4"), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestStrSet_Diff(t *testing.T) {
|
||||
@ -227,6 +240,14 @@ func TestStrSet_Complement(t *testing.T) {
|
||||
t.Assert(s3.Contains("4"), true)
|
||||
t.Assert(s3.Contains("5"), true)
|
||||
})
|
||||
|
||||
// Test with nil full set
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewStrSet()
|
||||
s1.Add("1", "2", "3")
|
||||
s3 := s1.Complement(nil)
|
||||
t.Assert(s3.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestNewIntSetFrom(t *testing.T) {
|
||||
|
||||
593
container/gset/gset_z_unit_t_set_test.go
Normal file
593
container/gset/gset_z_unit_t_set_test.go
Normal file
@ -0,0 +1,593 @@
|
||||
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
||||
//
|
||||
// This Source Code Form is subject to the terms of the MIT License.
|
||||
// If a copy of the MIT was not distributed with this file,
|
||||
// You can obtain one at https://github.com/gogf/gf.
|
||||
|
||||
package gset_test
|
||||
|
||||
import (
|
||||
"sync"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"github.com/gogf/gf/v2/container/gset"
|
||||
"github.com/gogf/gf/v2/internal/json"
|
||||
"github.com/gogf/gf/v2/test/gtest"
|
||||
)
|
||||
|
||||
func TestTSet_New(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
s.Add(1, 1, 2)
|
||||
s.Add([]int{3, 4}...)
|
||||
t.Assert(s.Size(), 4)
|
||||
t.AssertIN(1, s.Slice())
|
||||
t.AssertIN(2, s.Slice())
|
||||
t.AssertIN(3, s.Slice())
|
||||
t.AssertIN(4, s.Slice())
|
||||
t.AssertNI(0, s.Slice())
|
||||
t.Assert(s.Contains(4), true)
|
||||
t.Assert(s.Contains(5), false)
|
||||
s.Remove(1)
|
||||
t.Assert(s.Size(), 3)
|
||||
s.Clear()
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_NewFrom(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
|
||||
t.Assert(s.Size(), 3)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.Contains(3), true)
|
||||
t.Assert(s.Contains(4), false)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Add_NilData(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s gset.TSet[int]
|
||||
s.Add(1, 2, 3)
|
||||
t.Assert(s.Size(), 3)
|
||||
t.Assert(s.Contains(1), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_AddIfNotExist(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int](true)
|
||||
s.Add(1)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.AddIfNotExist(1), false)
|
||||
t.Assert(s.AddIfNotExist(2), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.AddIfNotExist(2), false)
|
||||
})
|
||||
|
||||
// Test with pointer type to test nil check
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[*int](true)
|
||||
|
||||
val := 1
|
||||
ptr := &val
|
||||
t.Assert(s.AddIfNotExist(ptr), true)
|
||||
t.Assert(s.AddIfNotExist(ptr), false)
|
||||
})
|
||||
|
||||
// Test nil data map initialization
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s gset.TSet[int]
|
||||
t.Assert(s.AddIfNotExist(1), true)
|
||||
t.Assert(s.Size(), 1)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_AddIfNotExistFunc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int](true)
|
||||
s.Add(1)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.Contains(2), false)
|
||||
t.Assert(s.AddIfNotExistFunc(2, func() bool { return false }), false)
|
||||
t.Assert(s.Contains(2), false)
|
||||
t.Assert(s.AddIfNotExistFunc(2, func() bool { return true }), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.AddIfNotExistFunc(2, func() bool { return true }), false)
|
||||
t.Assert(s.Contains(2), true)
|
||||
})
|
||||
|
||||
// Test concurrent scenario
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int](true)
|
||||
wg := sync.WaitGroup{}
|
||||
wg.Add(1)
|
||||
go func() {
|
||||
defer wg.Done()
|
||||
r := s.AddIfNotExistFunc(1, func() bool {
|
||||
time.Sleep(100 * time.Millisecond)
|
||||
return true
|
||||
})
|
||||
t.Assert(r, false)
|
||||
}()
|
||||
s.Add(1)
|
||||
wg.Wait()
|
||||
})
|
||||
|
||||
// Test nil data map initialization
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s gset.TSet[int]
|
||||
t.Assert(s.AddIfNotExistFunc(1, func() bool { return true }), true)
|
||||
t.Assert(s.Size(), 1)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_AddIfNotExistFuncLock(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int](true)
|
||||
s.Add(1)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.Contains(2), false)
|
||||
t.Assert(s.AddIfNotExistFuncLock(2, func() bool { return false }), false)
|
||||
t.Assert(s.Contains(2), false)
|
||||
t.Assert(s.AddIfNotExistFuncLock(2, func() bool { return true }), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.AddIfNotExistFuncLock(2, func() bool { return true }), false)
|
||||
t.Assert(s.Contains(2), true)
|
||||
})
|
||||
|
||||
// Test nil data map initialization
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s gset.TSet[int]
|
||||
t.Assert(s.AddIfNotExistFuncLock(1, func() bool { return true }), true)
|
||||
t.Assert(s.Size(), 1)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Iterator(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5}, true)
|
||||
var sum int
|
||||
s.Iterator(func(v int) bool {
|
||||
sum += v
|
||||
return true
|
||||
})
|
||||
t.Assert(sum, 15)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5}, true)
|
||||
var count int
|
||||
s.Iterator(func(v int) bool {
|
||||
count++
|
||||
return count < 3
|
||||
})
|
||||
t.Assert(count, 3)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Join(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
t.Assert(s.Join(","), "")
|
||||
s.Add(1, 2, 3)
|
||||
result := s.Join(",")
|
||||
t.Assert(len(result) > 0, true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_String(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s *gset.TSet[int]
|
||||
t.Assert(s.String(), "")
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
t.Assert(s.String(), "[]")
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
result := s.String()
|
||||
t.Assert(len(result) > 2, true)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[string]([]string{"a", "b", "c"})
|
||||
result := s.String()
|
||||
t.Assert(len(result) > 2, true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Equal(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
t.Assert(s1.Equal(s2), true)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{1, 2, 3, 4})
|
||||
t.Assert(s1.Equal(s2), false)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
t.Assert(s1.Equal(s1), true)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{1, 2, 4})
|
||||
t.Assert(s1.Equal(s2), false)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_IsSubsetOf(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2})
|
||||
s2 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
t.Assert(s1.IsSubsetOf(s2), true)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{1, 2})
|
||||
t.Assert(s1.IsSubsetOf(s2), false)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
t.Assert(s1.IsSubsetOf(s1), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Union(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
|
||||
s := s1.Union(s2)
|
||||
t.Assert(s.Size(), 5)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.Contains(3), true)
|
||||
t.Assert(s.Contains(4), true)
|
||||
t.Assert(s.Contains(5), true)
|
||||
})
|
||||
|
||||
// Test with nil set - should skip it and copy s1 data
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
var s2 *gset.TSet[int]
|
||||
s := s1.Union(s2)
|
||||
// Since s2 is nil and skipped, newSet will be empty
|
||||
// because the loop runs but nothing is copied when other is nil
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
|
||||
// Test with self
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s := s1.Union(s1)
|
||||
t.Assert(s.Size(), 3)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Diff(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
|
||||
s := s1.Diff(s2)
|
||||
t.Assert(s.Size(), 2)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.Contains(3), false)
|
||||
})
|
||||
|
||||
// Test with nil set - should skip it
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
var s2 *gset.TSet[int]
|
||||
s := s1.Diff(s2)
|
||||
// Since s2 is nil and skipped, newSet will be empty
|
||||
// because the loop runs but nothing is copied when other is nil
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
|
||||
// Test with self
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s := s1.Diff(s1)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Intersect(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
|
||||
s := s1.Intersect(s2)
|
||||
t.Assert(s.Size(), 1)
|
||||
t.Assert(s.Contains(3), true)
|
||||
})
|
||||
|
||||
// Test with nil set
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
var s2 *gset.TSet[int]
|
||||
s := s1.Intersect(s2)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
|
||||
// Test with self
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s := s1.Intersect(s1)
|
||||
t.Assert(s.Size(), 3)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Complement(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5})
|
||||
s := s1.Complement(s2)
|
||||
t.Assert(s.Size(), 2)
|
||||
t.Assert(s.Contains(4), true)
|
||||
t.Assert(s.Contains(5), true)
|
||||
})
|
||||
|
||||
// Test with self
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s := s1.Complement(s1)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Merge(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s2 := gset.NewTSetFrom[int]([]int{3, 4, 5})
|
||||
s1.Merge(s2)
|
||||
t.Assert(s1.Size(), 5)
|
||||
t.Assert(s1.Contains(1), true)
|
||||
t.Assert(s1.Contains(2), true)
|
||||
t.Assert(s1.Contains(3), true)
|
||||
t.Assert(s1.Contains(4), true)
|
||||
t.Assert(s1.Contains(5), true)
|
||||
})
|
||||
|
||||
// Test with nil set
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
var s2 *gset.TSet[int]
|
||||
s1.Merge(s2)
|
||||
t.Assert(s1.Size(), 3)
|
||||
})
|
||||
|
||||
// Test with self
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
s1.Merge(s1)
|
||||
t.Assert(s1.Size(), 3)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Sum(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
t.Assert(s.Sum(), 6)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Pop(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
item := s.Pop()
|
||||
t.Assert(s.Size(), 2)
|
||||
t.Assert(s.Contains(item), false)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
item := s.Pop()
|
||||
t.Assert(item, 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Pops(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3, 4, 5})
|
||||
items := s.Pops(3)
|
||||
t.Assert(len(items), 3)
|
||||
t.Assert(s.Size(), 2)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
items := s.Pops(-1)
|
||||
t.Assert(len(items), 3)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
items := s.Pops(0)
|
||||
t.Assert(items, nil)
|
||||
t.Assert(s.Size(), 3)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
items := s.Pops(10)
|
||||
t.Assert(len(items), 3)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_Walk(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2})
|
||||
s.Walk(func(item int) int {
|
||||
return item + 10
|
||||
})
|
||||
t.Assert(s.Size(), 2)
|
||||
t.Assert(s.Contains(11), true)
|
||||
t.Assert(s.Contains(12), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_MarshalJSON(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3})
|
||||
b, err := json.Marshal(s)
|
||||
t.AssertNil(err)
|
||||
t.Assert(len(b) > 0, true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_UnmarshalJSON(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
b := []byte(`[1,2,3]`)
|
||||
err := json.UnmarshalUseNumber(b, &s)
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 3)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.Contains(3), true)
|
||||
})
|
||||
|
||||
// Test with nil data map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s gset.TSet[int]
|
||||
b := []byte(`[1,2,3]`)
|
||||
err := json.UnmarshalUseNumber(b, &s)
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 3)
|
||||
})
|
||||
|
||||
// Test with invalid JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
b := []byte(`{invalid}`)
|
||||
err := json.UnmarshalUseNumber(b, &s)
|
||||
t.AssertNE(err, nil)
|
||||
})
|
||||
|
||||
// Test with empty array
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
b := []byte(`[]`)
|
||||
err := json.UnmarshalUseNumber(b, &s)
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_UnmarshalValue(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
err := s.UnmarshalValue([]byte(`[1,2,3]`))
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 3)
|
||||
t.Assert(s.Contains(1), true)
|
||||
t.Assert(s.Contains(2), true)
|
||||
t.Assert(s.Contains(3), true)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
err := s.UnmarshalValue(`[1,2,3]`)
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 3)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
err := s.UnmarshalValue([]int{1, 2, 3})
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 3)
|
||||
})
|
||||
|
||||
// Test with nil data map
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s gset.TSet[int]
|
||||
err := s.UnmarshalValue([]int{1, 2, 3})
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 3)
|
||||
})
|
||||
|
||||
// Test error case with invalid JSON
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
err := s.UnmarshalValue([]byte(`{invalid}`))
|
||||
t.AssertNE(err, nil)
|
||||
})
|
||||
|
||||
// Test with empty array for string/bytes case
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
err := s.UnmarshalValue([]byte(`[]`))
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
|
||||
// Test with empty slice for default case
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSet[int]()
|
||||
err := s.UnmarshalValue([]int{})
|
||||
t.AssertNil(err)
|
||||
t.Assert(s.Size(), 0)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_DeepCopy(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s1 := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
|
||||
s2 := s1.DeepCopy().(*gset.TSet[int])
|
||||
t.Assert(s1.Size(), s2.Size())
|
||||
t.Assert(s1.Contains(1), s2.Contains(1))
|
||||
t.Assert(s1.Contains(2), s2.Contains(2))
|
||||
t.Assert(s1.Contains(3), s2.Contains(3))
|
||||
|
||||
s1.Add(4)
|
||||
t.Assert(s1.Size(), 4)
|
||||
t.Assert(s2.Size(), 3)
|
||||
})
|
||||
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
var s1 *gset.TSet[int]
|
||||
s2 := s1.DeepCopy()
|
||||
t.Assert(s2, nil)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_LockFunc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
|
||||
s.LockFunc(func(m map[int]struct{}) {
|
||||
m[4] = struct{}{}
|
||||
})
|
||||
t.Assert(s.Size(), 4)
|
||||
t.Assert(s.Contains(4), true)
|
||||
})
|
||||
}
|
||||
|
||||
func TestTSet_RLockFunc(t *testing.T) {
|
||||
gtest.C(t, func(t *gtest.T) {
|
||||
s := gset.NewTSetFrom[int]([]int{1, 2, 3}, true)
|
||||
var sum int
|
||||
s.RLockFunc(func(m map[int]struct{}) {
|
||||
for k := range m {
|
||||
sum += k
|
||||
}
|
||||
})
|
||||
t.Assert(sum, 6)
|
||||
})
|
||||
}
|
||||
Reference in New Issue
Block a user