mirror of
https://gitlab.com/pulsechaincom/go-pulse.git
synced 2024-12-25 12:57:17 +00:00
201 lines
4.1 KiB
Go
201 lines
4.1 KiB
Go
|
package set
|
||
|
|
||
|
import (
|
||
|
"sync"
|
||
|
)
|
||
|
|
||
|
// Set defines a thread safe set data structure.
|
||
|
type Set struct {
|
||
|
set
|
||
|
l sync.RWMutex // we name it because we don't want to expose it
|
||
|
}
|
||
|
|
||
|
// New creates and initialize a new Set. It's accept a variable number of
|
||
|
// arguments to populate the initial set. If nothing passed a Set with zero
|
||
|
// size is created.
|
||
|
func New(items ...interface{}) *Set {
|
||
|
s := &Set{}
|
||
|
s.m = make(map[interface{}]struct{})
|
||
|
|
||
|
// Ensure interface compliance
|
||
|
var _ Interface = s
|
||
|
|
||
|
s.Add(items...)
|
||
|
return s
|
||
|
}
|
||
|
|
||
|
// New creates and initalizes a new Set interface. It accepts a variable
|
||
|
// number of arguments to populate the initial set. If nothing is passed a
|
||
|
// zero size Set based on the struct is created.
|
||
|
func (s *Set) New(items ...interface{}) Interface {
|
||
|
return New(items...)
|
||
|
}
|
||
|
|
||
|
// Add includes the specified items (one or more) to the set. The underlying
|
||
|
// Set s is modified. If passed nothing it silently returns.
|
||
|
func (s *Set) Add(items ...interface{}) {
|
||
|
if len(items) == 0 {
|
||
|
return
|
||
|
}
|
||
|
|
||
|
s.l.Lock()
|
||
|
defer s.l.Unlock()
|
||
|
|
||
|
for _, item := range items {
|
||
|
s.m[item] = keyExists
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Remove deletes the specified items from the set. The underlying Set s is
|
||
|
// modified. If passed nothing it silently returns.
|
||
|
func (s *Set) Remove(items ...interface{}) {
|
||
|
if len(items) == 0 {
|
||
|
return
|
||
|
}
|
||
|
|
||
|
s.l.Lock()
|
||
|
defer s.l.Unlock()
|
||
|
|
||
|
for _, item := range items {
|
||
|
delete(s.m, item)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// Pop deletes and return an item from the set. The underlying Set s is
|
||
|
// modified. If set is empty, nil is returned.
|
||
|
func (s *Set) Pop() interface{} {
|
||
|
s.l.RLock()
|
||
|
for item := range s.m {
|
||
|
s.l.RUnlock()
|
||
|
s.l.Lock()
|
||
|
delete(s.m, item)
|
||
|
s.l.Unlock()
|
||
|
return item
|
||
|
}
|
||
|
s.l.RUnlock()
|
||
|
return nil
|
||
|
}
|
||
|
|
||
|
// Has looks for the existence of items passed. It returns false if nothing is
|
||
|
// passed. For multiple items it returns true only if all of the items exist.
|
||
|
func (s *Set) Has(items ...interface{}) bool {
|
||
|
// assume checked for empty item, which not exist
|
||
|
if len(items) == 0 {
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
s.l.RLock()
|
||
|
defer s.l.RUnlock()
|
||
|
|
||
|
has := true
|
||
|
for _, item := range items {
|
||
|
if _, has = s.m[item]; !has {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
return has
|
||
|
}
|
||
|
|
||
|
// Size returns the number of items in a set.
|
||
|
func (s *Set) Size() int {
|
||
|
s.l.RLock()
|
||
|
defer s.l.RUnlock()
|
||
|
|
||
|
l := len(s.m)
|
||
|
return l
|
||
|
}
|
||
|
|
||
|
// Clear removes all items from the set.
|
||
|
func (s *Set) Clear() {
|
||
|
s.l.Lock()
|
||
|
defer s.l.Unlock()
|
||
|
|
||
|
s.m = make(map[interface{}]struct{})
|
||
|
}
|
||
|
|
||
|
// IsEqual test whether s and t are the same in size and have the same items.
|
||
|
func (s *Set) IsEqual(t Interface) bool {
|
||
|
s.l.RLock()
|
||
|
defer s.l.RUnlock()
|
||
|
|
||
|
// Force locking only if given set is threadsafe.
|
||
|
if conv, ok := t.(*Set); ok {
|
||
|
conv.l.RLock()
|
||
|
defer conv.l.RUnlock()
|
||
|
}
|
||
|
|
||
|
// return false if they are no the same size
|
||
|
if sameSize := len(s.m) == t.Size(); !sameSize {
|
||
|
return false
|
||
|
}
|
||
|
|
||
|
equal := true
|
||
|
t.Each(func(item interface{}) bool {
|
||
|
_, equal = s.m[item]
|
||
|
return equal // if false, Each() will end
|
||
|
})
|
||
|
|
||
|
return equal
|
||
|
}
|
||
|
|
||
|
// IsSubset tests whether t is a subset of s.
|
||
|
func (s *Set) IsSubset(t Interface) (subset bool) {
|
||
|
s.l.RLock()
|
||
|
defer s.l.RUnlock()
|
||
|
|
||
|
subset = true
|
||
|
|
||
|
t.Each(func(item interface{}) bool {
|
||
|
_, subset = s.m[item]
|
||
|
return subset
|
||
|
})
|
||
|
|
||
|
return
|
||
|
}
|
||
|
|
||
|
// Each traverses the items in the Set, calling the provided function for each
|
||
|
// set member. Traversal will continue until all items in the Set have been
|
||
|
// visited, or if the closure returns false.
|
||
|
func (s *Set) Each(f func(item interface{}) bool) {
|
||
|
s.l.RLock()
|
||
|
defer s.l.RUnlock()
|
||
|
|
||
|
for item := range s.m {
|
||
|
if !f(item) {
|
||
|
break
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// List returns a slice of all items. There is also StringSlice() and
|
||
|
// IntSlice() methods for returning slices of type string or int.
|
||
|
func (s *Set) List() []interface{} {
|
||
|
s.l.RLock()
|
||
|
defer s.l.RUnlock()
|
||
|
|
||
|
list := make([]interface{}, 0, len(s.m))
|
||
|
|
||
|
for item := range s.m {
|
||
|
list = append(list, item)
|
||
|
}
|
||
|
|
||
|
return list
|
||
|
}
|
||
|
|
||
|
// Copy returns a new Set with a copy of s.
|
||
|
func (s *Set) Copy() Interface {
|
||
|
return New(s.List()...)
|
||
|
}
|
||
|
|
||
|
// Merge is like Union, however it modifies the current set it's applied on
|
||
|
// with the given t set.
|
||
|
func (s *Set) Merge(t Interface) {
|
||
|
s.l.Lock()
|
||
|
defer s.l.Unlock()
|
||
|
|
||
|
t.Each(func(item interface{}) bool {
|
||
|
s.m[item] = keyExists
|
||
|
return true
|
||
|
})
|
||
|
}
|