gf/container/gset/gset_any_set.go

508 lines
11 KiB
Go
Raw Normal View History

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,
// You can obtain one at https://github.com/gogf/gf.
2018-01-03 10:38:53 +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 (
"bytes"
"github.com/gogf/gf/internal/json"
2019-07-29 21:01:19 +08:00
"github.com/gogf/gf/internal/rwmutex"
"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 {
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.
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.
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{}),
mu: rwmutex.Create(safe...),
2019-06-19 09:06:52 +08:00
}
2019-01-31 21:15:39 +08:00
}
// NewFrom returns a new set from <items>.
// Parameter <items> can be either a variable of any type, or a slice.
func NewFrom(items interface{}, safe ...bool) *Set {
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,
mu: rwmutex.Create(safe...),
}
}
// 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.
func (set *Set) Add(items ...interface{}) {
2019-06-19 09:06:52 +08:00
set.mu.Lock()
if set.data == nil {
set.data = make(map[interface{}]struct{})
}
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
}
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
}
}
2020-04-13 23:44:43 +08:00
return false
}
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.
//
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
}
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
}
}
}
2020-04-13 23:44:43 +08:00
return false
}
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.
//
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-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
}
}
}
2020-04-13 23:44:43 +08:00
return false
}
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 {
var ok bool
2019-06-19 09:06:52 +08:00
set.mu.RLock()
if set.data != nil {
_, ok = set.data[item]
}
2019-06-19 09:06:52 +08:00
set.mu.RUnlock()
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()
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()
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 {
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 *Set) String() string {
set.mu.RLock()
defer set.mu.RUnlock()
var (
s = ""
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()
2019-02-02 15:16:45 +08:00
}
2019-04-24 18:15:50 +08:00
// LockFunc locks writing with callback function <f>.
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>.
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) {
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) {
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) {
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) {
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-26 08:57:48 +08:00
// Pops randomly pops an item from set.
func (set *Set) Pop() interface{} {
set.mu.Lock()
defer set.mu.Unlock()
2019-09-30 14:37:05 +08:00
for k, _ := range set.data {
delete(set.data, k)
2019-04-26 08:57:48 +08:00
return k
}
return nil
}
// Pops randomly pops <size> items from set.
// It returns all items if size == -1.
func (set *Set) Pops(size int) []interface{} {
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
}
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 {
delete(set.data, k)
2019-04-26 08:57:48 +08:00
array[index] = k
index++
if index == size {
break
}
}
return array
2019-06-19 09:06:52 +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()
m := make(map[interface{}]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 *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()
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
}
// 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()
if set.data == nil {
set.data = make(map[interface{}]struct{})
}
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
}