2021-01-17 21:46:25 +08:00
|
|
|
// Copyright GoFrame Author(https://goframe.org). All Rights Reserved.
|
2018-01-03 10:38:53 +08:00
|
|
|
//
|
|
|
|
// 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,
|
2019-02-02 16:18:25 +08:00
|
|
|
// You can obtain one at https://github.com/gogf/gf.
|
2018-01-03 10:38:53 +08:00
|
|
|
|
2019-04-03 23:39:31 +08:00
|
|
|
// Package gset provides kinds of concurrent-safe/unsafe sets.
|
2018-01-03 10:38:53 +08:00
|
|
|
package gset
|
2018-08-30 13:00:49 +08:00
|
|
|
|
2019-01-31 21:15:39 +08:00
|
|
|
import (
|
2019-10-01 16:03:18 +08:00
|
|
|
"bytes"
|
2020-06-17 21:16:25 +08:00
|
|
|
"github.com/gogf/gf/internal/json"
|
2019-07-29 21:01:19 +08:00
|
|
|
"github.com/gogf/gf/internal/rwmutex"
|
2019-10-01 16:03:18 +08:00
|
|
|
"github.com/gogf/gf/text/gstr"
|
2019-07-29 21:01:19 +08:00
|
|
|
"github.com/gogf/gf/util/gconv"
|
2019-01-31 21:15:39 +08:00
|
|
|
)
|
|
|
|
|
|
|
|
type Set struct {
|
2020-04-07 20:41:49 +08:00
|
|
|
mu rwmutex.RWMutex
|
2019-09-30 14:37:05 +08:00
|
|
|
data map[interface{}]struct{}
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
2018-08-30 13:00:49 +08:00
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// New create and returns a new set, which contains un-repeated items.
|
2019-11-30 18:33:51 +08:00
|
|
|
// The parameter <safe> is used to specify whether using set in concurrent-safety,
|
2019-04-24 18:15:50 +08:00
|
|
|
// which is false in default.
|
2019-07-23 23:20:27 +08:00
|
|
|
func New(safe ...bool) *Set {
|
|
|
|
return NewSet(safe...)
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-02-02 15:16:45 +08:00
|
|
|
// See New.
|
2019-07-23 23:20:27 +08:00
|
|
|
func NewSet(safe ...bool) *Set {
|
2019-06-19 09:06:52 +08:00
|
|
|
return &Set{
|
2019-09-30 14:37:05 +08:00
|
|
|
data: make(map[interface{}]struct{}),
|
2020-04-07 20:41:49 +08:00
|
|
|
mu: rwmutex.Create(safe...),
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:52:24 +08:00
|
|
|
// NewFrom returns a new set from <items>.
|
|
|
|
// Parameter <items> can be either a variable of any type, or a slice.
|
2019-07-23 23:20:27 +08:00
|
|
|
func NewFrom(items interface{}, safe ...bool) *Set {
|
2019-04-24 18:52:24 +08:00
|
|
|
m := make(map[interface{}]struct{})
|
|
|
|
for _, v := range gconv.Interfaces(items) {
|
|
|
|
m[v] = struct{}{}
|
|
|
|
}
|
|
|
|
return &Set{
|
2019-09-30 14:37:05 +08:00
|
|
|
data: m,
|
2020-04-07 20:41:49 +08:00
|
|
|
mu: rwmutex.Create(safe...),
|
2019-04-24 18:52:24 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-18 13:30:49 +08:00
|
|
|
// Iterator iterates the set readonly with given callback function <f>,
|
2019-02-02 15:16:45 +08:00
|
|
|
// if <f> returns true then continue iterating; or false to stop.
|
2020-04-13 23:44:43 +08:00
|
|
|
func (set *Set) Iterator(f func(v interface{}) bool) {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, _ := range set.data {
|
2019-06-19 09:06:52 +08:00
|
|
|
if !f(k) {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Add adds one or multiple items to the set.
|
2020-06-04 21:46:22 +08:00
|
|
|
func (set *Set) Add(items ...interface{}) {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.Lock()
|
2020-04-07 20:41:49 +08:00
|
|
|
if set.data == nil {
|
|
|
|
set.data = make(map[interface{}]struct{})
|
|
|
|
}
|
2020-06-04 21:46:22 +08:00
|
|
|
for _, v := range items {
|
2019-09-30 14:37:05 +08:00
|
|
|
set.data[v] = struct{}{}
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
set.mu.Unlock()
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2020-04-13 23:44:43 +08:00
|
|
|
// 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 *Set) AddIfNotExist(item interface{}) bool {
|
|
|
|
if item == nil {
|
|
|
|
return false
|
|
|
|
}
|
2019-10-13 22:31:28 +08:00
|
|
|
if !set.Contains(item) {
|
2020-04-13 23:44:43 +08:00
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
|
|
|
if set.data == nil {
|
|
|
|
set.data = make(map[interface{}]struct{})
|
|
|
|
}
|
|
|
|
if _, ok := set.data[item]; !ok {
|
|
|
|
set.data[item] = struct{}{}
|
|
|
|
return true
|
|
|
|
}
|
2019-10-13 22:31:28 +08:00
|
|
|
}
|
2020-04-13 23:44:43 +08:00
|
|
|
return false
|
2019-10-13 22:31:28 +08:00
|
|
|
}
|
|
|
|
|
2020-04-13 23:44:43 +08:00
|
|
|
// AddIfNotExistFunc 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.
|
2019-10-13 22:31:28 +08:00
|
|
|
//
|
2020-04-13 23:44:43 +08:00
|
|
|
// 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 interface{}, f func() bool) bool {
|
|
|
|
if item == nil {
|
|
|
|
return false
|
|
|
|
}
|
2019-10-13 22:31:28 +08:00
|
|
|
if !set.Contains(item) {
|
2020-04-13 23:44:43 +08:00
|
|
|
if f() {
|
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
|
|
|
if set.data == nil {
|
|
|
|
set.data = make(map[interface{}]struct{})
|
|
|
|
}
|
|
|
|
if _, ok := set.data[item]; !ok {
|
|
|
|
set.data[item] = struct{}{}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
}
|
2019-10-13 22:31:28 +08:00
|
|
|
}
|
2020-04-13 23:44:43 +08:00
|
|
|
return false
|
2019-10-13 22:31:28 +08:00
|
|
|
}
|
|
|
|
|
2020-04-13 23:44:43 +08:00
|
|
|
// AddIfNotExistFunc 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.
|
2019-10-13 22:31:28 +08:00
|
|
|
//
|
2020-04-13 23:44:43 +08:00
|
|
|
// 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 interface{}, f func() bool) bool {
|
|
|
|
if item == nil {
|
|
|
|
return false
|
2020-04-07 20:41:49 +08:00
|
|
|
}
|
2020-04-13 23:44:43 +08:00
|
|
|
if !set.Contains(item) {
|
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
|
|
|
if set.data == nil {
|
|
|
|
set.data = make(map[interface{}]struct{})
|
|
|
|
}
|
|
|
|
if f() {
|
|
|
|
if _, ok := set.data[item]; !ok {
|
|
|
|
set.data[item] = struct{}{}
|
|
|
|
return true
|
|
|
|
}
|
2019-10-13 22:31:28 +08:00
|
|
|
}
|
|
|
|
}
|
2020-04-13 23:44:43 +08:00
|
|
|
return false
|
2019-10-13 22:31:28 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Contains checks whether the set contains <item>.
|
2019-01-31 21:15:39 +08:00
|
|
|
func (set *Set) Contains(item interface{}) bool {
|
2020-04-07 20:41:49 +08:00
|
|
|
var ok bool
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
2020-04-07 20:41:49 +08:00
|
|
|
if set.data != nil {
|
|
|
|
_, ok = set.data[item]
|
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RUnlock()
|
2020-04-07 20:41:49 +08:00
|
|
|
return ok
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Remove deletes <item> from set.
|
2020-04-13 23:44:43 +08:00
|
|
|
func (set *Set) Remove(item interface{}) {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.Lock()
|
2020-04-07 20:41:49 +08:00
|
|
|
if set.data != nil {
|
|
|
|
delete(set.data, item)
|
|
|
|
}
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.Unlock()
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Size returns the size of the set.
|
2019-01-31 21:15:39 +08:00
|
|
|
func (set *Set) Size() int {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
2019-09-30 14:37:05 +08:00
|
|
|
l := len(set.data)
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RUnlock()
|
|
|
|
return l
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Clear deletes all items of the set.
|
2020-04-13 23:44:43 +08:00
|
|
|
func (set *Set) Clear() {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.Lock()
|
2019-09-30 14:37:05 +08:00
|
|
|
set.data = make(map[interface{}]struct{})
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.Unlock()
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Slice returns the a of items of the set as slice.
|
2019-01-31 21:15:39 +08:00
|
|
|
func (set *Set) Slice() []interface{} {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
2020-04-07 20:41:49 +08:00
|
|
|
var (
|
|
|
|
i = 0
|
|
|
|
ret = make([]interface{}, len(set.data))
|
|
|
|
)
|
2019-09-30 14:37:05 +08:00
|
|
|
for item := range set.data {
|
2019-06-19 09:06:52 +08:00
|
|
|
ret[i] = item
|
|
|
|
i++
|
|
|
|
}
|
|
|
|
set.mu.RUnlock()
|
|
|
|
return ret
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Join joins items with a string <glue>.
|
2019-02-02 15:16:45 +08:00
|
|
|
func (set *Set) Join(glue string) string {
|
2019-10-01 16:03:18 +08:00
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
2020-04-07 20:41:49 +08:00
|
|
|
if len(set.data) == 0 {
|
|
|
|
return ""
|
|
|
|
}
|
|
|
|
var (
|
|
|
|
l = len(set.data)
|
|
|
|
i = 0
|
|
|
|
buffer = bytes.NewBuffer(nil)
|
|
|
|
)
|
2019-10-13 22:31:28 +08:00
|
|
|
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 *Set) String() string {
|
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
2020-04-07 20:41:49 +08:00
|
|
|
var (
|
|
|
|
s = ""
|
|
|
|
l = len(set.data)
|
|
|
|
i = 0
|
|
|
|
buffer = bytes.NewBuffer(nil)
|
|
|
|
)
|
2019-10-13 22:31:28 +08:00
|
|
|
buffer.WriteByte('[')
|
2019-10-01 16:03:18 +08:00
|
|
|
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 {
|
2019-10-13 22:31:28 +08:00
|
|
|
buffer.WriteByte(',')
|
2019-10-01 16:03:18 +08:00
|
|
|
}
|
|
|
|
i++
|
|
|
|
}
|
2019-10-13 22:31:28 +08:00
|
|
|
buffer.WriteByte(']')
|
2019-10-01 16:03:18 +08:00
|
|
|
return buffer.String()
|
2019-02-02 15:16:45 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// LockFunc locks writing with callback function <f>.
|
2019-05-12 21:26:01 +08:00
|
|
|
func (set *Set) LockFunc(f func(m map[interface{}]struct{})) {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
2019-09-30 14:37:05 +08:00
|
|
|
f(set.data)
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// RLockFunc locks reading with callback function <f>.
|
2019-05-12 21:26:01 +08:00
|
|
|
func (set *Set) RLockFunc(f func(m map[interface{}]struct{})) {
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
2019-09-30 14:37:05 +08:00
|
|
|
f(set.data)
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// Equal checks whether the two sets equal.
|
2019-01-31 21:15:39 +08:00
|
|
|
func (set *Set) Equal(other *Set) bool {
|
2019-06-19 09:06:52 +08:00
|
|
|
if set == other {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
|
|
|
other.mu.RLock()
|
|
|
|
defer other.mu.RUnlock()
|
2019-09-30 14:37:05 +08:00
|
|
|
if len(set.data) != len(other.data) {
|
2019-06-19 09:06:52 +08:00
|
|
|
return false
|
|
|
|
}
|
2019-09-30 14:37:05 +08:00
|
|
|
for key := range set.data {
|
|
|
|
if _, ok := other.data[key]; !ok {
|
2019-06-19 09:06:52 +08:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// IsSubsetOf checks whether the current set is a sub-set of <other>.
|
2019-01-31 21:15:39 +08:00
|
|
|
func (set *Set) IsSubsetOf(other *Set) bool {
|
2019-06-19 09:06:52 +08:00
|
|
|
if set == other {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
|
|
|
other.mu.RLock()
|
|
|
|
defer other.mu.RUnlock()
|
2019-09-30 14:37:05 +08:00
|
|
|
for key := range set.data {
|
|
|
|
if _, ok := other.data[key]; !ok {
|
2019-06-19 09:06:52 +08:00
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// 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>.
|
2019-06-19 09:06:52 +08:00
|
|
|
func (set *Set) Union(others ...*Set) (newSet *Set) {
|
2020-04-07 20:41:49 +08:00
|
|
|
newSet = NewSet()
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
|
|
|
for _, other := range others {
|
|
|
|
if set != other {
|
|
|
|
other.mu.RLock()
|
|
|
|
}
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, v := range set.data {
|
|
|
|
newSet.data[k] = v
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
if set != other {
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, v := range other.data {
|
|
|
|
newSet.data[k] = v
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if set != other {
|
|
|
|
other.mu.RUnlock()
|
|
|
|
}
|
|
|
|
}
|
2019-02-01 17:30:23 +08:00
|
|
|
|
2019-06-19 09:06:52 +08:00
|
|
|
return
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// 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>.
|
2019-06-19 09:06:52 +08:00
|
|
|
func (set *Set) Diff(others ...*Set) (newSet *Set) {
|
2020-04-07 20:41:49 +08:00
|
|
|
newSet = NewSet()
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
|
|
|
for _, other := range others {
|
|
|
|
if set == other {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
other.mu.RLock()
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, v := range set.data {
|
|
|
|
if _, ok := other.data[k]; !ok {
|
|
|
|
newSet.data[k] = v
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
other.mu.RUnlock()
|
|
|
|
}
|
|
|
|
return
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// 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>.
|
2019-06-19 09:06:52 +08:00
|
|
|
func (set *Set) Intersect(others ...*Set) (newSet *Set) {
|
2020-04-07 20:41:49 +08:00
|
|
|
newSet = NewSet()
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
|
|
|
for _, other := range others {
|
|
|
|
if set != other {
|
|
|
|
other.mu.RLock()
|
|
|
|
}
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, v := range set.data {
|
|
|
|
if _, ok := other.data[k]; ok {
|
|
|
|
newSet.data[k] = v
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if set != other {
|
|
|
|
other.mu.RUnlock()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
2019-01-31 21:15:39 +08:00
|
|
|
}
|
|
|
|
|
2019-04-24 18:15:50 +08:00
|
|
|
// 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>.
|
2019-02-02 15:16:45 +08:00
|
|
|
//
|
2019-04-24 18:15:50 +08:00
|
|
|
// It returns the difference between <full> and <set>
|
|
|
|
// if the given set <full> is not the full set of <set>.
|
2019-01-31 21:15:39 +08:00
|
|
|
func (set *Set) Complement(full *Set) (newSet *Set) {
|
2020-04-07 20:41:49 +08:00
|
|
|
newSet = NewSet()
|
2019-06-19 09:06:52 +08:00
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
|
|
|
if set != full {
|
|
|
|
full.mu.RLock()
|
|
|
|
defer full.mu.RUnlock()
|
|
|
|
}
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, v := range full.data {
|
|
|
|
if _, ok := set.data[k]; !ok {
|
|
|
|
newSet.data[k] = v
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return
|
2019-04-24 18:15:50 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Merge adds items from <others> sets into <set>.
|
2019-06-19 09:06:52 +08:00
|
|
|
func (set *Set) Merge(others ...*Set) *Set {
|
2019-04-24 18:15:50 +08:00
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
|
|
|
for _, other := range others {
|
|
|
|
if set != other {
|
|
|
|
other.mu.RLock()
|
|
|
|
}
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, v := range other.data {
|
|
|
|
set.data[k] = v
|
2019-04-24 18:15:50 +08:00
|
|
|
}
|
|
|
|
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 *Set) Sum() (sum int) {
|
|
|
|
set.mu.RLock()
|
|
|
|
defer set.mu.RUnlock()
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, _ := range set.data {
|
2019-04-24 18:15:50 +08:00
|
|
|
sum += gconv.Int(k)
|
|
|
|
}
|
|
|
|
return
|
2019-04-25 22:14:20 +08:00
|
|
|
}
|
|
|
|
|
2019-04-26 08:57:48 +08:00
|
|
|
// Pops randomly pops an item from set.
|
2019-08-09 09:51:52 +08:00
|
|
|
func (set *Set) Pop() interface{} {
|
2019-10-16 23:33:06 +08:00
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, _ := range set.data {
|
2019-10-16 23:33:06 +08:00
|
|
|
delete(set.data, k)
|
2019-04-26 08:57:48 +08:00
|
|
|
return k
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pops randomly pops <size> items from set.
|
2019-10-16 23:33:06 +08:00
|
|
|
// It returns all items if size == -1.
|
2019-04-25 22:14:20 +08:00
|
|
|
func (set *Set) Pops(size int) []interface{} {
|
2019-10-16 23:33:06 +08:00
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
|
|
|
if size > len(set.data) || size == -1 {
|
2019-09-30 14:37:05 +08:00
|
|
|
size = len(set.data)
|
2019-04-26 08:57:48 +08:00
|
|
|
}
|
2019-10-16 23:33:06 +08:00
|
|
|
if size <= 0 {
|
|
|
|
return nil
|
|
|
|
}
|
2019-04-26 08:57:48 +08:00
|
|
|
index := 0
|
|
|
|
array := make([]interface{}, size)
|
2019-09-30 14:37:05 +08:00
|
|
|
for k, _ := range set.data {
|
2019-10-16 23:33:06 +08:00
|
|
|
delete(set.data, k)
|
2019-04-26 08:57:48 +08:00
|
|
|
array[index] = k
|
|
|
|
index++
|
|
|
|
if index == size {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2019-04-25 22:14:20 +08:00
|
|
|
return array
|
2019-06-19 09:06:52 +08:00
|
|
|
}
|
2019-09-03 23:18:54 +08:00
|
|
|
|
2020-04-27 21:18:42 +08:00
|
|
|
// Walk applies a user supplied function <f> to every item of set.
|
|
|
|
func (set *Set) Walk(f func(item interface{}) interface{}) *Set {
|
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
2020-06-04 21:46:22 +08:00
|
|
|
m := make(map[interface{}]struct{}, len(set.data))
|
2020-04-27 21:18:42 +08:00
|
|
|
for k, v := range set.data {
|
2020-06-04 21:46:22 +08:00
|
|
|
m[f(k)] = v
|
2020-04-27 21:18:42 +08:00
|
|
|
}
|
2020-06-04 21:46:22 +08:00
|
|
|
set.data = m
|
2020-04-27 21:18:42 +08:00
|
|
|
return set
|
|
|
|
}
|
|
|
|
|
2019-09-03 23:18:54 +08:00
|
|
|
// MarshalJSON implements the interface MarshalJSON for json.Marshal.
|
|
|
|
func (set *Set) MarshalJSON() ([]byte, error) {
|
|
|
|
return json.Marshal(set.Slice())
|
|
|
|
}
|
2019-09-30 14:37:05 +08:00
|
|
|
|
|
|
|
// UnmarshalJSON implements the interface UnmarshalJSON for json.Unmarshal.
|
|
|
|
func (set *Set) UnmarshalJSON(b []byte) error {
|
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
2020-04-07 20:41:49 +08:00
|
|
|
if set.data == nil {
|
|
|
|
set.data = make(map[interface{}]struct{})
|
|
|
|
}
|
2019-09-30 14:37:05 +08:00
|
|
|
var array []interface{}
|
|
|
|
if err := json.Unmarshal(b, &array); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
for _, v := range array {
|
|
|
|
set.data[v] = struct{}{}
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
2020-01-20 19:56:42 +08:00
|
|
|
|
|
|
|
// UnmarshalValue is an interface implement which sets any type of value for set.
|
|
|
|
func (set *Set) UnmarshalValue(value interface{}) (err error) {
|
|
|
|
set.mu.Lock()
|
|
|
|
defer set.mu.Unlock()
|
2020-04-07 20:41:49 +08:00
|
|
|
if set.data == nil {
|
|
|
|
set.data = make(map[interface{}]struct{})
|
|
|
|
}
|
2020-01-20 19:56:42 +08:00
|
|
|
var array []interface{}
|
|
|
|
switch value.(type) {
|
|
|
|
case string, []byte:
|
|
|
|
err = json.Unmarshal(gconv.Bytes(value), &array)
|
|
|
|
default:
|
|
|
|
array = gconv.SliceAny(value)
|
|
|
|
}
|
|
|
|
for _, v := range array {
|
|
|
|
set.data[v] = struct{}{}
|
|
|
|
}
|
|
|
|
return
|
|
|
|
}
|