mirror of https://github.com/ethereum/go-ethereum
all: switch out defunct set library to different one (#16873)
* keystore, ethash, eth, miner, rpc, whisperv6: tech debt with now defunct set. * whisperv5: swap out gopkg.in/fatih/set.v0 with supported setpull/17184/head
Ralph Caraveo III
6 years ago
committed by
Péter Szilágyi
parent
eb7f901289
commit
5d30be412b
22
vendor/gopkg.in/fatih/set.v0/LICENSE.md → vendor/github.com/deckarep/golang-set/LICENSE
generated
vendored
22
vendor/gopkg.in/fatih/set.v0/LICENSE.md → vendor/github.com/deckarep/golang-set/LICENSE
generated
vendored
@ -1,20 +1,22 @@ |
||||
The MIT License (MIT) |
||||
Open Source Initiative OSI - The MIT License (MIT):Licensing |
||||
|
||||
Copyright (c) 2013 Fatih Arslan |
||||
The MIT License (MIT) |
||||
Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com) |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of |
||||
this software and associated documentation files (the "Software"), to deal in |
||||
the Software without restriction, including without limitation the rights to |
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of |
||||
the Software, and to permit persons to whom the Software is furnished to do so, |
||||
subject to the following conditions: |
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies |
||||
of the Software, and to permit persons to whom the Software is furnished to do |
||||
so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS |
||||
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR |
||||
COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER |
||||
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
||||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
@ -0,0 +1,95 @@ |
||||
[](https://travis-ci.org/deckarep/golang-set) |
||||
[](https://goreportcard.com/report/github.com/deckarep/golang-set) |
||||
[](http://godoc.org/github.com/deckarep/golang-set) |
||||
|
||||
## golang-set |
||||
|
||||
|
||||
The missing set collection for the Go language. Until Go has sets built-in...use this. |
||||
|
||||
Coming from Python one of the things I miss is the superbly wonderful set collection. This is my attempt to mimic the primary features of the set from Python. |
||||
You can of course argue that there is no need for a set in Go, otherwise the creators would have added one to the standard library. To those I say simply ignore this repository |
||||
and carry-on and to the rest that find this useful please contribute in helping me make it better by: |
||||
|
||||
* Helping to make more idiomatic improvements to the code. |
||||
* Helping to increase the performance of it. ~~(So far, no attempt has been made, but since it uses a map internally, I expect it to be mostly performant.)~~ |
||||
* Helping to make the unit-tests more robust and kick-ass. |
||||
* Helping to fill in the [documentation.](http://godoc.org/github.com/deckarep/golang-set) |
||||
* Simply offering feedback and suggestions. (Positive, constructive feedback is appreciated.) |
||||
|
||||
I have to give some credit for helping seed the idea with this post on [stackoverflow.](http://programmers.stackexchange.com/questions/177428/sets-data-structure-in-golang) |
||||
|
||||
*Update* - as of 3/9/2014, you can use a compile-time generic version of this package in the [gen](http://clipperhouse.github.io/gen/) framework. This framework allows you to use the golang-set in a completely generic and type-safe way by allowing you to generate a supporting .go file based on your custom types. |
||||
|
||||
## Features (as of 9/22/2014) |
||||
|
||||
* a CartesianProduct() method has been added with unit-tests: [Read more about the cartesian product](http://en.wikipedia.org/wiki/Cartesian_product) |
||||
|
||||
## Features (as of 9/15/2014) |
||||
|
||||
* a PowerSet() method has been added with unit-tests: [Read more about the Power set](http://en.wikipedia.org/wiki/Power_set) |
||||
|
||||
## Features (as of 4/22/2014) |
||||
|
||||
* One common interface to both implementations |
||||
* Two set implementations to choose from |
||||
* a thread-safe implementation designed for concurrent use |
||||
* a non-thread-safe implementation designed for performance |
||||
* 75 benchmarks for both implementations |
||||
* 35 unit tests for both implementations |
||||
* 14 concurrent tests for the thread-safe implementation |
||||
|
||||
|
||||
|
||||
Please see the unit test file for additional usage examples. The Python set documentation will also do a better job than I can of explaining how a set typically [works.](http://docs.python.org/2/library/sets.html) Please keep in mind |
||||
however that the Python set is a built-in type and supports additional features and syntax that make it awesome. |
||||
|
||||
## Examples but not exhaustive: |
||||
|
||||
```go |
||||
requiredClasses := mapset.NewSet() |
||||
requiredClasses.Add("Cooking") |
||||
requiredClasses.Add("English") |
||||
requiredClasses.Add("Math") |
||||
requiredClasses.Add("Biology") |
||||
|
||||
scienceSlice := []interface{}{"Biology", "Chemistry"} |
||||
scienceClasses := mapset.NewSetFromSlice(scienceSlice) |
||||
|
||||
electiveClasses := mapset.NewSet() |
||||
electiveClasses.Add("Welding") |
||||
electiveClasses.Add("Music") |
||||
electiveClasses.Add("Automotive") |
||||
|
||||
bonusClasses := mapset.NewSet() |
||||
bonusClasses.Add("Go Programming") |
||||
bonusClasses.Add("Python Programming") |
||||
|
||||
//Show me all the available classes I can take |
||||
allClasses := requiredClasses.Union(scienceClasses).Union(electiveClasses).Union(bonusClasses) |
||||
fmt.Println(allClasses) //Set{Cooking, English, Math, Chemistry, Welding, Biology, Music, Automotive, Go Programming, Python Programming} |
||||
|
||||
|
||||
//Is cooking considered a science class? |
||||
fmt.Println(scienceClasses.Contains("Cooking")) //false |
||||
|
||||
//Show me all classes that are not science classes, since I hate science. |
||||
fmt.Println(allClasses.Difference(scienceClasses)) //Set{Music, Automotive, Go Programming, Python Programming, Cooking, English, Math, Welding} |
||||
|
||||
//Which science classes are also required classes? |
||||
fmt.Println(scienceClasses.Intersect(requiredClasses)) //Set{Biology} |
||||
|
||||
//How many bonus classes do you offer? |
||||
fmt.Println(bonusClasses.Cardinality()) //2 |
||||
|
||||
//Do you have the following classes? Welding, Automotive and English? |
||||
fmt.Println(allClasses.IsSuperset(mapset.NewSetFromSlice([]interface{}{"Welding", "Automotive", "English"}))) //true |
||||
``` |
||||
|
||||
Thanks! |
||||
|
||||
-Ralph |
||||
|
||||
[](https://bitdeli.com/free "Bitdeli Badge") |
||||
|
||||
[](https://github.com/igrigorik/ga-beacon) |
||||
@ -0,0 +1,58 @@ |
||||
/* |
||||
Open Source Initiative OSI - The MIT License (MIT):Licensing |
||||
|
||||
The MIT License (MIT) |
||||
Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com) |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of |
||||
this software and associated documentation files (the "Software"), to deal in |
||||
the Software without restriction, including without limitation the rights to |
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies |
||||
of the Software, and to permit persons to whom the Software is furnished to do |
||||
so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
*/ |
||||
|
||||
package mapset |
||||
|
||||
// Iterator defines an iterator over a Set, its C channel can be used to range over the Set's
|
||||
// elements.
|
||||
type Iterator struct { |
||||
C <-chan interface{} |
||||
stop chan struct{} |
||||
} |
||||
|
||||
// Stop stops the Iterator, no further elements will be received on C, C will be closed.
|
||||
func (i *Iterator) Stop() { |
||||
// Allows for Stop() to be called multiple times
|
||||
// (close() panics when called on already closed channel)
|
||||
defer func() { |
||||
recover() |
||||
}() |
||||
|
||||
close(i.stop) |
||||
|
||||
// Exhaust any remaining elements.
|
||||
for range i.C { |
||||
} |
||||
} |
||||
|
||||
// newIterator returns a new Iterator instance together with its item and stop channels.
|
||||
func newIterator() (*Iterator, chan<- interface{}, <-chan struct{}) { |
||||
itemChan := make(chan interface{}) |
||||
stopChan := make(chan struct{}) |
||||
return &Iterator{ |
||||
C: itemChan, |
||||
stop: stopChan, |
||||
}, itemChan, stopChan |
||||
} |
||||
@ -0,0 +1,217 @@ |
||||
/* |
||||
Open Source Initiative OSI - The MIT License (MIT):Licensing |
||||
|
||||
The MIT License (MIT) |
||||
Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com) |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of |
||||
this software and associated documentation files (the "Software"), to deal in |
||||
the Software without restriction, including without limitation the rights to |
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies |
||||
of the Software, and to permit persons to whom the Software is furnished to do |
||||
so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
*/ |
||||
|
||||
// Package mapset implements a simple and generic set collection.
|
||||
// Items stored within it are unordered and unique. It supports
|
||||
// typical set operations: membership testing, intersection, union,
|
||||
// difference, symmetric difference and cloning.
|
||||
//
|
||||
// Package mapset provides two implementations of the Set
|
||||
// interface. The default implementation is safe for concurrent
|
||||
// access, but a non-thread-safe implementation is also provided for
|
||||
// programs that can benefit from the slight speed improvement and
|
||||
// that can enforce mutual exclusion through other means.
|
||||
package mapset |
||||
|
||||
// Set is the primary interface provided by the mapset package. It
|
||||
// represents an unordered set of data and a large number of
|
||||
// operations that can be applied to that set.
|
||||
type Set interface { |
||||
// Adds an element to the set. Returns whether
|
||||
// the item was added.
|
||||
Add(i interface{}) bool |
||||
|
||||
// Returns the number of elements in the set.
|
||||
Cardinality() int |
||||
|
||||
// Removes all elements from the set, leaving
|
||||
// the empty set.
|
||||
Clear() |
||||
|
||||
// Returns a clone of the set using the same
|
||||
// implementation, duplicating all keys.
|
||||
Clone() Set |
||||
|
||||
// Returns whether the given items
|
||||
// are all in the set.
|
||||
Contains(i ...interface{}) bool |
||||
|
||||
// Returns the difference between this set
|
||||
// and other. The returned set will contain
|
||||
// all elements of this set that are not also
|
||||
// elements of other.
|
||||
//
|
||||
// Note that the argument to Difference
|
||||
// must be of the same type as the receiver
|
||||
// of the method. Otherwise, Difference will
|
||||
// panic.
|
||||
Difference(other Set) Set |
||||
|
||||
// Determines if two sets are equal to each
|
||||
// other. If they have the same cardinality
|
||||
// and contain the same elements, they are
|
||||
// considered equal. The order in which
|
||||
// the elements were added is irrelevant.
|
||||
//
|
||||
// Note that the argument to Equal must be
|
||||
// of the same type as the receiver of the
|
||||
// method. Otherwise, Equal will panic.
|
||||
Equal(other Set) bool |
||||
|
||||
// Returns a new set containing only the elements
|
||||
// that exist only in both sets.
|
||||
//
|
||||
// Note that the argument to Intersect
|
||||
// must be of the same type as the receiver
|
||||
// of the method. Otherwise, Intersect will
|
||||
// panic.
|
||||
Intersect(other Set) Set |
||||
|
||||
// Determines if every element in this set is in
|
||||
// the other set but the two sets are not equal.
|
||||
//
|
||||
// Note that the argument to IsProperSubset
|
||||
// must be of the same type as the receiver
|
||||
// of the method. Otherwise, IsProperSubset
|
||||
// will panic.
|
||||
IsProperSubset(other Set) bool |
||||
|
||||
// Determines if every element in the other set
|
||||
// is in this set but the two sets are not
|
||||
// equal.
|
||||
//
|
||||
// Note that the argument to IsSuperset
|
||||
// must be of the same type as the receiver
|
||||
// of the method. Otherwise, IsSuperset will
|
||||
// panic.
|
||||
IsProperSuperset(other Set) bool |
||||
|
||||
// Determines if every element in this set is in
|
||||
// the other set.
|
||||
//
|
||||
// Note that the argument to IsSubset
|
||||
// must be of the same type as the receiver
|
||||
// of the method. Otherwise, IsSubset will
|
||||
// panic.
|
||||
IsSubset(other Set) bool |
||||
|
||||
// Determines if every element in the other set
|
||||
// is in this set.
|
||||
//
|
||||
// Note that the argument to IsSuperset
|
||||
// must be of the same type as the receiver
|
||||
// of the method. Otherwise, IsSuperset will
|
||||
// panic.
|
||||
IsSuperset(other Set) bool |
||||
|
||||
// Iterates over elements and executes the passed func against each element.
|
||||
// If passed func returns true, stop iteration at the time.
|
||||
Each(func(interface{}) bool) |
||||
|
||||
// Returns a channel of elements that you can
|
||||
// range over.
|
||||
Iter() <-chan interface{} |
||||
|
||||
// Returns an Iterator object that you can
|
||||
// use to range over the set.
|
||||
Iterator() *Iterator |
||||
|
||||
// Remove a single element from the set.
|
||||
Remove(i interface{}) |
||||
|
||||
// Provides a convenient string representation
|
||||
// of the current state of the set.
|
||||
String() string |
||||
|
||||
// Returns a new set with all elements which are
|
||||
// in either this set or the other set but not in both.
|
||||
//
|
||||
// Note that the argument to SymmetricDifference
|
||||
// must be of the same type as the receiver
|
||||
// of the method. Otherwise, SymmetricDifference
|
||||
// will panic.
|
||||
SymmetricDifference(other Set) Set |
||||
|
||||
// Returns a new set with all elements in both sets.
|
||||
//
|
||||
// Note that the argument to Union must be of the
|
||||
|
||||
// same type as the receiver of the method.
|
||||
// Otherwise, IsSuperset will panic.
|
||||
Union(other Set) Set |
||||
|
||||
// Pop removes and returns an arbitrary item from the set.
|
||||
Pop() interface{} |
||||
|
||||
// Returns all subsets of a given set (Power Set).
|
||||
PowerSet() Set |
||||
|
||||
// Returns the Cartesian Product of two sets.
|
||||
CartesianProduct(other Set) Set |
||||
|
||||
// Returns the members of the set as a slice.
|
||||
ToSlice() []interface{} |
||||
} |
||||
|
||||
// NewSet creates and returns a reference to an empty set. Operations
|
||||
// on the resulting set are thread-safe.
|
||||
func NewSet(s ...interface{}) Set { |
||||
set := newThreadSafeSet() |
||||
for _, item := range s { |
||||
set.Add(item) |
||||
} |
||||
return &set |
||||
} |
||||
|
||||
// NewSetWith creates and returns a new set with the given elements.
|
||||
// Operations on the resulting set are thread-safe.
|
||||
func NewSetWith(elts ...interface{}) Set { |
||||
return NewSetFromSlice(elts) |
||||
} |
||||
|
||||
// NewSetFromSlice creates and returns a reference to a set from an
|
||||
// existing slice. Operations on the resulting set are thread-safe.
|
||||
func NewSetFromSlice(s []interface{}) Set { |
||||
a := NewSet(s...) |
||||
return a |
||||
} |
||||
|
||||
// NewThreadUnsafeSet creates and returns a reference to an empty set.
|
||||
// Operations on the resulting set are not thread-safe.
|
||||
func NewThreadUnsafeSet() Set { |
||||
set := newThreadUnsafeSet() |
||||
return &set |
||||
} |
||||
|
||||
// NewThreadUnsafeSetFromSlice creates and returns a reference to a
|
||||
// set from an existing slice. Operations on the resulting set are
|
||||
// not thread-safe.
|
||||
func NewThreadUnsafeSetFromSlice(s []interface{}) Set { |
||||
a := NewThreadUnsafeSet() |
||||
for _, item := range s { |
||||
a.Add(item) |
||||
} |
||||
return a |
||||
} |
||||
@ -0,0 +1,277 @@ |
||||
/* |
||||
Open Source Initiative OSI - The MIT License (MIT):Licensing |
||||
|
||||
The MIT License (MIT) |
||||
Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com) |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of |
||||
this software and associated documentation files (the "Software"), to deal in |
||||
the Software without restriction, including without limitation the rights to |
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies |
||||
of the Software, and to permit persons to whom the Software is furnished to do |
||||
so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
*/ |
||||
|
||||
package mapset |
||||
|
||||
import "sync" |
||||
|
||||
type threadSafeSet struct { |
||||
s threadUnsafeSet |
||||
sync.RWMutex |
||||
} |
||||
|
||||
func newThreadSafeSet() threadSafeSet { |
||||
return threadSafeSet{s: newThreadUnsafeSet()} |
||||
} |
||||
|
||||
func (set *threadSafeSet) Add(i interface{}) bool { |
||||
set.Lock() |
||||
ret := set.s.Add(i) |
||||
set.Unlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) Contains(i ...interface{}) bool { |
||||
set.RLock() |
||||
ret := set.s.Contains(i...) |
||||
set.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) IsSubset(other Set) bool { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
o.RLock() |
||||
|
||||
ret := set.s.IsSubset(&o.s) |
||||
set.RUnlock() |
||||
o.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) IsProperSubset(other Set) bool { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
defer set.RUnlock() |
||||
o.RLock() |
||||
defer o.RUnlock() |
||||
|
||||
return set.s.IsProperSubset(&o.s) |
||||
} |
||||
|
||||
func (set *threadSafeSet) IsSuperset(other Set) bool { |
||||
return other.IsSubset(set) |
||||
} |
||||
|
||||
func (set *threadSafeSet) IsProperSuperset(other Set) bool { |
||||
return other.IsProperSubset(set) |
||||
} |
||||
|
||||
func (set *threadSafeSet) Union(other Set) Set { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
o.RLock() |
||||
|
||||
unsafeUnion := set.s.Union(&o.s).(*threadUnsafeSet) |
||||
ret := &threadSafeSet{s: *unsafeUnion} |
||||
set.RUnlock() |
||||
o.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) Intersect(other Set) Set { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
o.RLock() |
||||
|
||||
unsafeIntersection := set.s.Intersect(&o.s).(*threadUnsafeSet) |
||||
ret := &threadSafeSet{s: *unsafeIntersection} |
||||
set.RUnlock() |
||||
o.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) Difference(other Set) Set { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
o.RLock() |
||||
|
||||
unsafeDifference := set.s.Difference(&o.s).(*threadUnsafeSet) |
||||
ret := &threadSafeSet{s: *unsafeDifference} |
||||
set.RUnlock() |
||||
o.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) SymmetricDifference(other Set) Set { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
o.RLock() |
||||
|
||||
unsafeDifference := set.s.SymmetricDifference(&o.s).(*threadUnsafeSet) |
||||
ret := &threadSafeSet{s: *unsafeDifference} |
||||
set.RUnlock() |
||||
o.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) Clear() { |
||||
set.Lock() |
||||
set.s = newThreadUnsafeSet() |
||||
set.Unlock() |
||||
} |
||||
|
||||
func (set *threadSafeSet) Remove(i interface{}) { |
||||
set.Lock() |
||||
delete(set.s, i) |
||||
set.Unlock() |
||||
} |
||||
|
||||
func (set *threadSafeSet) Cardinality() int { |
||||
set.RLock() |
||||
defer set.RUnlock() |
||||
return len(set.s) |
||||
} |
||||
|
||||
func (set *threadSafeSet) Each(cb func(interface{}) bool) { |
||||
set.RLock() |
||||
for elem := range set.s { |
||||
if cb(elem) { |
||||
break |
||||
} |
||||
} |
||||
set.RUnlock() |
||||
} |
||||
|
||||
func (set *threadSafeSet) Iter() <-chan interface{} { |
||||
ch := make(chan interface{}) |
||||
go func() { |
||||
set.RLock() |
||||
|
||||
for elem := range set.s { |
||||
ch <- elem |
||||
} |
||||
close(ch) |
||||
set.RUnlock() |
||||
}() |
||||
|
||||
return ch |
||||
} |
||||
|
||||
func (set *threadSafeSet) Iterator() *Iterator { |
||||
iterator, ch, stopCh := newIterator() |
||||
|
||||
go func() { |
||||
set.RLock() |
||||
L: |
||||
for elem := range set.s { |
||||
select { |
||||
case <-stopCh: |
||||
break L |
||||
case ch <- elem: |
||||
} |
||||
} |
||||
close(ch) |
||||
set.RUnlock() |
||||
}() |
||||
|
||||
return iterator |
||||
} |
||||
|
||||
func (set *threadSafeSet) Equal(other Set) bool { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
o.RLock() |
||||
|
||||
ret := set.s.Equal(&o.s) |
||||
set.RUnlock() |
||||
o.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) Clone() Set { |
||||
set.RLock() |
||||
|
||||
unsafeClone := set.s.Clone().(*threadUnsafeSet) |
||||
ret := &threadSafeSet{s: *unsafeClone} |
||||
set.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) String() string { |
||||
set.RLock() |
||||
ret := set.s.String() |
||||
set.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) PowerSet() Set { |
||||
set.RLock() |
||||
ret := set.s.PowerSet() |
||||
set.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) Pop() interface{} { |
||||
set.Lock() |
||||
defer set.Unlock() |
||||
return set.s.Pop() |
||||
} |
||||
|
||||
func (set *threadSafeSet) CartesianProduct(other Set) Set { |
||||
o := other.(*threadSafeSet) |
||||
|
||||
set.RLock() |
||||
o.RLock() |
||||
|
||||
unsafeCartProduct := set.s.CartesianProduct(&o.s).(*threadUnsafeSet) |
||||
ret := &threadSafeSet{s: *unsafeCartProduct} |
||||
set.RUnlock() |
||||
o.RUnlock() |
||||
return ret |
||||
} |
||||
|
||||
func (set *threadSafeSet) ToSlice() []interface{} { |
||||
keys := make([]interface{}, 0, set.Cardinality()) |
||||
set.RLock() |
||||
for elem := range set.s { |
||||
keys = append(keys, elem) |
||||
} |
||||
set.RUnlock() |
||||
return keys |
||||
} |
||||
|
||||
func (set *threadSafeSet) MarshalJSON() ([]byte, error) { |
||||
set.RLock() |
||||
b, err := set.s.MarshalJSON() |
||||
set.RUnlock() |
||||
|
||||
return b, err |
||||
} |
||||
|
||||
func (set *threadSafeSet) UnmarshalJSON(p []byte) error { |
||||
set.RLock() |
||||
err := set.s.UnmarshalJSON(p) |
||||
set.RUnlock() |
||||
|
||||
return err |
||||
} |
||||
@ -0,0 +1,337 @@ |
||||
/* |
||||
Open Source Initiative OSI - The MIT License (MIT):Licensing |
||||
|
||||
The MIT License (MIT) |
||||
Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com) |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of |
||||
this software and associated documentation files (the "Software"), to deal in |
||||
the Software without restriction, including without limitation the rights to |
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies |
||||
of the Software, and to permit persons to whom the Software is furnished to do |
||||
so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
*/ |
||||
|
||||
package mapset |
||||
|
||||
import ( |
||||
"bytes" |
||||
"encoding/json" |
||||
"fmt" |
||||
"reflect" |
||||
"strings" |
||||
) |
||||
|
||||
type threadUnsafeSet map[interface{}]struct{} |
||||
|
||||
// An OrderedPair represents a 2-tuple of values.
|
||||
type OrderedPair struct { |
||||
First interface{} |
||||
Second interface{} |
||||
} |
||||
|
||||
func newThreadUnsafeSet() threadUnsafeSet { |
||||
return make(threadUnsafeSet) |
||||
} |
||||
|
||||
// Equal says whether two 2-tuples contain the same values in the same order.
|
||||
func (pair *OrderedPair) Equal(other OrderedPair) bool { |
||||
if pair.First == other.First && |
||||
pair.Second == other.Second { |
||||
return true |
||||
} |
||||
|
||||
return false |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Add(i interface{}) bool { |
||||
_, found := (*set)[i] |
||||
if found { |
||||
return false //False if it existed already
|
||||
} |
||||
|
||||
(*set)[i] = struct{}{} |
||||
return true |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Contains(i ...interface{}) bool { |
||||
for _, val := range i { |
||||
if _, ok := (*set)[val]; !ok { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) IsSubset(other Set) bool { |
||||
_ = other.(*threadUnsafeSet) |
||||
for elem := range *set { |
||||
if !other.Contains(elem) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) IsProperSubset(other Set) bool { |
||||
return set.IsSubset(other) && !set.Equal(other) |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) IsSuperset(other Set) bool { |
||||
return other.IsSubset(set) |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) IsProperSuperset(other Set) bool { |
||||
return set.IsSuperset(other) && !set.Equal(other) |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Union(other Set) Set { |
||||
o := other.(*threadUnsafeSet) |
||||
|
||||
unionedSet := newThreadUnsafeSet() |
||||
|
||||
for elem := range *set { |
||||
unionedSet.Add(elem) |
||||
} |
||||
for elem := range *o { |
||||
unionedSet.Add(elem) |
||||
} |
||||
return &unionedSet |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Intersect(other Set) Set { |
||||
o := other.(*threadUnsafeSet) |
||||
|
||||
intersection := newThreadUnsafeSet() |
||||
// loop over smaller set
|
||||
if set.Cardinality() < other.Cardinality() { |
||||
for elem := range *set { |
||||
if other.Contains(elem) { |
||||
intersection.Add(elem) |
||||
} |
||||
} |
||||
} else { |
||||
for elem := range *o { |
||||
if set.Contains(elem) { |
||||
intersection.Add(elem) |
||||
} |
||||
} |
||||
} |
||||
return &intersection |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Difference(other Set) Set { |
||||
_ = other.(*threadUnsafeSet) |
||||
|
||||
difference := newThreadUnsafeSet() |
||||
for elem := range *set { |
||||
if !other.Contains(elem) { |
||||
difference.Add(elem) |
||||
} |
||||
} |
||||
return &difference |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) SymmetricDifference(other Set) Set { |
||||
_ = other.(*threadUnsafeSet) |
||||
|
||||
aDiff := set.Difference(other) |
||||
bDiff := other.Difference(set) |
||||
return aDiff.Union(bDiff) |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Clear() { |
||||
*set = newThreadUnsafeSet() |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Remove(i interface{}) { |
||||
delete(*set, i) |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Cardinality() int { |
||||
return len(*set) |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Each(cb func(interface{}) bool) { |
||||
for elem := range *set { |
||||
if cb(elem) { |
||||
break |
||||
} |
||||
} |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Iter() <-chan interface{} { |
||||
ch := make(chan interface{}) |
||||
go func() { |
||||
for elem := range *set { |
||||
ch <- elem |
||||
} |
||||
close(ch) |
||||
}() |
||||
|
||||
return ch |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Iterator() *Iterator { |
||||
iterator, ch, stopCh := newIterator() |
||||
|
||||
go func() { |
||||
L: |
||||
for elem := range *set { |
||||
select { |
||||
case <-stopCh: |
||||
break L |
||||
case ch <- elem: |
||||
} |
||||
} |
||||
close(ch) |
||||
}() |
||||
|
||||
return iterator |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Equal(other Set) bool { |
||||
_ = other.(*threadUnsafeSet) |
||||
|
||||
if set.Cardinality() != other.Cardinality() { |
||||
return false |
||||
} |
||||
for elem := range *set { |
||||
if !other.Contains(elem) { |
||||
return false |
||||
} |
||||
} |
||||
return true |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Clone() Set { |
||||
clonedSet := newThreadUnsafeSet() |
||||
for elem := range *set { |
||||
clonedSet.Add(elem) |
||||
} |
||||
return &clonedSet |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) String() string { |
||||
items := make([]string, 0, len(*set)) |
||||
|
||||
for elem := range *set { |
||||
items = append(items, fmt.Sprintf("%v", elem)) |
||||
} |
||||
return fmt.Sprintf("Set{%s}", strings.Join(items, ", ")) |
||||
} |
||||
|
||||
// String outputs a 2-tuple in the form "(A, B)".
|
||||
func (pair OrderedPair) String() string { |
||||
return fmt.Sprintf("(%v, %v)", pair.First, pair.Second) |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) Pop() interface{} { |
||||
for item := range *set { |
||||
delete(*set, item) |
||||
return item |
||||
} |
||||
return nil |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) PowerSet() Set { |
||||
powSet := NewThreadUnsafeSet() |
||||
nullset := newThreadUnsafeSet() |
||||
powSet.Add(&nullset) |
||||
|
||||
for es := range *set { |
||||
u := newThreadUnsafeSet() |
||||
j := powSet.Iter() |
||||
for er := range j { |
||||
p := newThreadUnsafeSet() |
||||
if reflect.TypeOf(er).Name() == "" { |
||||
k := er.(*threadUnsafeSet) |
||||
for ek := range *(k) { |
||||
p.Add(ek) |
||||
} |
||||
} else { |
||||
p.Add(er) |
||||
} |
||||
p.Add(es) |
||||
u.Add(&p) |
||||
} |
||||
|
||||
powSet = powSet.Union(&u) |
||||
} |
||||
|
||||
return powSet |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) CartesianProduct(other Set) Set { |
||||
o := other.(*threadUnsafeSet) |
||||
cartProduct := NewThreadUnsafeSet() |
||||
|
||||
for i := range *set { |
||||
for j := range *o { |
||||
elem := OrderedPair{First: i, Second: j} |
||||
cartProduct.Add(elem) |
||||
} |
||||
} |
||||
|
||||
return cartProduct |
||||
} |
||||
|
||||
func (set *threadUnsafeSet) ToSlice() []interface{} { |
||||
keys := make([]interface{}, 0, set.Cardinality()) |
||||
for elem := range *set { |
||||
keys = append(keys, elem) |
||||
} |
||||
|
||||
return keys |
||||
} |
||||
|
||||
// MarshalJSON creates a JSON array from the set, it marshals all elements
|
||||
func (set *threadUnsafeSet) MarshalJSON() ([]byte, error) { |
||||
items := make([]string, 0, set.Cardinality()) |
||||
|
||||
for elem := range *set { |
||||
b, err := json.Marshal(elem) |
||||
if err != nil { |
||||
return nil, err |
||||
} |
||||
|
||||
items = append(items, string(b)) |
||||
} |
||||
|
||||
return []byte(fmt.Sprintf("[%s]", strings.Join(items, ","))), nil |
||||
} |
||||
|
||||
// UnmarshalJSON recreates a set from a JSON array, it only decodes
|
||||
// primitive types. Numbers are decoded as json.Number.
|
||||
func (set *threadUnsafeSet) UnmarshalJSON(b []byte) error { |
||||
var i []interface{} |
||||
|
||||
d := json.NewDecoder(bytes.NewReader(b)) |
||||
d.UseNumber() |
||||
err := d.Decode(&i) |
||||
if err != nil { |
||||
return err |
||||
} |
||||
|
||||
for _, v := range i { |
||||
switch t := v.(type) { |
||||
case []interface{}, map[string]interface{}: |
||||
continue |
||||
default: |
||||
set.Add(t) |
||||
} |
||||
} |
||||
|
||||
return nil |
||||
} |
||||
@ -1,245 +0,0 @@ |
||||
# Set [](https://godoc.org/gopkg.in/fatih/set.v0) [](https://travis-ci.org/fatih/set) |
||||
|
||||
Set is a basic and simple, hash-based, **Set** data structure implementation |
||||
in Go (Golang). |
||||
|
||||
Set provides both threadsafe and non-threadsafe implementations of a generic |
||||
set data structure. The thread safety encompasses all operations on one set. |
||||
Operations on multiple sets are consistent in that the elements of each set |
||||
used was valid at exactly one point in time between the start and the end of |
||||
the operation. Because it's thread safe, you can use it concurrently with your |
||||
goroutines. |
||||
|
||||
For usage see examples below or click on the godoc badge. |
||||
|
||||
## Install and Usage |
||||
|
||||
Install the package with: |
||||
|
||||
```bash |
||||
go get gopkg.in/fatih/set.v0 |
||||
``` |
||||
|
||||
Import it with: |
||||
|
||||
```go |
||||
import "gopkg.in/fatih/set.v0" |
||||
``` |
||||
|
||||
and use `set` as the package name inside the code. |
||||
|
||||
## Examples |
||||
|
||||
#### Initialization of a new Set |
||||
|
||||
```go |
||||
|
||||
// create a set with zero items |
||||
s := set.New() |
||||
s := set.NewNonTS() // non thread-safe version |
||||
|
||||
// ... or with some initial values |
||||
s := set.New("istanbul", "frankfurt", 30.123, "san francisco", 1234) |
||||
s := set.NewNonTS("kenya", "ethiopia", "sumatra") |
||||
|
||||
``` |
||||
|
||||
#### Basic Operations |
||||
|
||||
```go |
||||
// add items |
||||
s.Add("istanbul") |
||||
s.Add("istanbul") // nothing happens if you add duplicate item |
||||
|
||||
// add multiple items |
||||
s.Add("ankara", "san francisco", 3.14) |
||||
|
||||
// remove item |
||||
s.Remove("frankfurt") |
||||
s.Remove("frankfurt") // nothing happes if you remove a nonexisting item |
||||
|
||||
// remove multiple items |
||||
s.Remove("barcelona", 3.14, "ankara") |
||||
|
||||
// removes an arbitary item and return it |
||||
item := s.Pop() |
||||
|
||||
// create a new copy |
||||
other := s.Copy() |
||||
|
||||
// remove all items |
||||
s.Clear() |
||||
|
||||
// number of items in the set |
||||
len := s.Size() |
||||
|
||||
// return a list of items |
||||
items := s.List() |
||||
|
||||
// string representation of set |
||||
fmt.Printf("set is %s", s.String()) |
||||
|
||||
``` |
||||
|
||||
#### Check Operations |
||||
|
||||
```go |
||||
// check for set emptiness, returns true if set is empty |
||||
s.IsEmpty() |
||||
|
||||
// check for a single item exist |
||||
s.Has("istanbul") |
||||
|
||||
// ... or for multiple items. This will return true if all of the items exist. |
||||
s.Has("istanbul", "san francisco", 3.14) |
||||
|
||||
// create two sets for the following checks... |
||||
s := s.New("1", "2", "3", "4", "5") |
||||
t := s.New("1", "2", "3") |
||||
|
||||
|
||||
// check if they are the same |
||||
if !s.IsEqual(t) { |
||||
fmt.Println("s is not equal to t") |
||||
} |
||||
|
||||
// if s contains all elements of t |
||||
if s.IsSubset(t) { |
||||
fmt.Println("t is a subset of s") |
||||
} |
||||
|
||||
// ... or if s is a superset of t |
||||
if t.IsSuperset(s) { |
||||
fmt.Println("s is a superset of t") |
||||
} |
||||
|
||||
|
||||
``` |
||||
|
||||
#### Set Operations |
||||
|
||||
|
||||
```go |
||||
// let us initialize two sets with some values |
||||
a := set.New("ankara", "berlin", "san francisco") |
||||
b := set.New("frankfurt", "berlin") |
||||
|
||||
// creates a new set with the items in a and b combined. |
||||
// [frankfurt, berlin, ankara, san francisco] |
||||
c := set.Union(a, b) |
||||
|
||||
// contains items which is in both a and b |
||||
// [berlin] |
||||
c := set.Intersection(a, b) |
||||
|
||||
// contains items which are in a but not in b |
||||
// [ankara, san francisco] |
||||
c := set.Difference(a, b) |
||||
|
||||
// contains items which are in one of either, but not in both. |
||||
// [frankfurt, ankara, san francisco] |
||||
c := set.SymmetricDifference(a, b) |
||||
|
||||
``` |
||||
|
||||
```go |
||||
// like Union but saves the result back into a. |
||||
a.Merge(b) |
||||
|
||||
// removes the set items which are in b from a and saves the result back into a. |
||||
a.Separate(b) |
||||
|
||||
``` |
||||
|
||||
#### Multiple Set Operations |
||||
|
||||
```go |
||||
a := set.New("1", "3", "4", "5") |
||||
b := set.New("2", "3", "4", "5") |
||||
c := set.New("4", "5", "6", "7") |
||||
|
||||
// creates a new set with items in a, b and c |
||||
// [1 2 3 4 5 6 7] |
||||
u := set.Union(a, b, c) |
||||
|
||||
// creates a new set with items in a but not in b and c |
||||
// [1] |
||||
u := set.Difference(a, b, c) |
||||
|
||||
// creates a new set with items that are common to a, b and c |
||||
// [5] |
||||
u := set.Intersection(a, b, c) |
||||
``` |
||||
|
||||
#### Helper methods |
||||
|
||||
The Slice functions below are a convenient way to extract or convert your Set data |
||||
into basic data types. |
||||
|
||||
|
||||
```go |
||||
// create a set of mixed types |
||||
s := set.New("ankara", "5", "8", "san francisco", 13, 21) |
||||
|
||||
|
||||
// convert s into a slice of strings (type is []string) |
||||
// [ankara 5 8 san francisco] |
||||
t := set.StringSlice(s) |
||||
|
||||
|
||||
// u contains a slice of ints (type is []int) |
||||
// [13, 21] |
||||
u := set.IntSlice(s) |
||||
|
||||
``` |
||||
|
||||
#### Concurrent safe usage |
||||
|
||||
Below is an example of a concurrent way that uses set. We call ten functions |
||||
concurrently and wait until they are finished. It basically creates a new |
||||
string for each goroutine and adds it to our set. |
||||
|
||||
```go |
||||
package main |
||||
|
||||
import ( |
||||
"fmt" |
||||
"github.com/fatih/set" |
||||
"strconv" |
||||
"sync" |
||||
) |
||||
|
||||
func main() { |
||||
var wg sync.WaitGroup // this is just for waiting until all goroutines finish |
||||
|
||||
// Initialize our thread safe Set |
||||
s := set.New() |
||||
|
||||
// Add items concurrently (item1, item2, and so on) |
||||
for i := 0; i < 10; i++ { |
||||
wg.Add(1) |
||||
go func(i int) { |
||||
item := "item" + strconv.Itoa(i) |
||||
fmt.Println("adding", item) |
||||
s.Add(item) |
||||
wg.Done() |
||||
}(i) |
||||
} |
||||
|
||||
// Wait until all concurrent calls finished and print our set |
||||
wg.Wait() |
||||
fmt.Println(s) |
||||
} |
||||
``` |
||||
|
||||
## Credits |
||||
|
||||
* [Fatih Arslan](https://github.com/fatih) |
||||
* [Arne Hormann](https://github.com/arnehormann) |
||||
* [Sam Boyer](https://github.com/sdboyer) |
||||
* [Ralph Loizzo](https://github.com/friartech) |
||||
|
||||
## License |
||||
|
||||
The MIT License (MIT) - see LICENSE.md for more details |
||||
|
||||
@ -1,121 +0,0 @@ |
||||
// Package set provides both threadsafe and non-threadsafe implementations of
|
||||
// a generic set data structure. In the threadsafe set, safety encompasses all
|
||||
// operations on one set. Operations on multiple sets are consistent in that
|
||||
// the elements of each set used was valid at exactly one point in time
|
||||
// between the start and the end of the operation.
|
||||
package set |
||||
|
||||
// Interface is describing a Set. Sets are an unordered, unique list of values.
|
||||
type Interface interface { |
||||
New(items ...interface{}) Interface |
||||
Add(items ...interface{}) |
||||
Remove(items ...interface{}) |
||||
Pop() interface{} |
||||
Has(items ...interface{}) bool |
||||
Size() int |
||||
Clear() |
||||
IsEmpty() bool |
||||
IsEqual(s Interface) bool |
||||
IsSubset(s Interface) bool |
||||
IsSuperset(s Interface) bool |
||||
Each(func(interface{}) bool) |
||||
String() string |
||||
List() []interface{} |
||||
Copy() Interface |
||||
Merge(s Interface) |
||||
Separate(s Interface) |
||||
} |
||||
|
||||
// helpful to not write everywhere struct{}{}
|
||||
var keyExists = struct{}{} |
||||
|
||||
// Union is the merger of multiple sets. It returns a new set with all the
|
||||
// elements present in all the sets that are passed.
|
||||
//
|
||||
// The dynamic type of the returned set is determined by the first passed set's
|
||||
// implementation of the New() method.
|
||||
func Union(set1, set2 Interface, sets ...Interface) Interface { |
||||
u := set1.Copy() |
||||
set2.Each(func(item interface{}) bool { |
||||
u.Add(item) |
||||
return true |
||||
}) |
||||
for _, set := range sets { |
||||
set.Each(func(item interface{}) bool { |
||||
u.Add(item) |
||||
return true |
||||
}) |
||||
} |
||||
|
||||
return u |
||||
} |
||||
|
||||
// Difference returns a new set which contains items which are in in the first
|
||||
// set but not in the others. Unlike the Difference() method you can use this
|
||||
// function separately with multiple sets.
|
||||
func Difference(set1, set2 Interface, sets ...Interface) Interface { |
||||
s := set1.Copy() |
||||
s.Separate(set2) |
||||
for _, set := range sets { |
||||
s.Separate(set) // seperate is thread safe
|
||||
} |
||||
return s |
||||
} |
||||
|
||||
// Intersection returns a new set which contains items that only exist in all given sets.
|
||||
func Intersection(set1, set2 Interface, sets ...Interface) Interface { |
||||
all := Union(set1, set2, sets...) |
||||
result := Union(set1, set2, sets...) |
||||
|
||||
all.Each(func(item interface{}) bool { |
||||
if !set1.Has(item) || !set2.Has(item) { |
||||
result.Remove(item) |
||||
} |
||||
|
||||
for _, set := range sets { |
||||
if !set.Has(item) { |
||||
result.Remove(item) |
||||
} |
||||
} |
||||
return true |
||||
}) |
||||
return result |
||||
} |
||||
|
||||
// SymmetricDifference returns a new set which s is the difference of items which are in
|
||||
// one of either, but not in both.
|
||||
func SymmetricDifference(s Interface, t Interface) Interface { |
||||
u := Difference(s, t) |
||||
v := Difference(t, s) |
||||
return Union(u, v) |
||||
} |
||||
|
||||
// StringSlice is a helper function that returns a slice of strings of s. If
|
||||
// the set contains mixed types of items only items of type string are returned.
|
||||
func StringSlice(s Interface) []string { |
||||
slice := make([]string, 0) |
||||
for _, item := range s.List() { |
||||
v, ok := item.(string) |
||||
if !ok { |
||||
continue |
||||
} |
||||
|
||||
slice = append(slice, v) |
||||
} |
||||
return slice |
||||
} |
||||
|
||||
// IntSlice is a helper function that returns a slice of ints of s. If
|
||||
// the set contains mixed types of items only items of type int are returned.
|
||||
func IntSlice(s Interface) []int { |
||||
slice := make([]int, 0) |
||||
for _, item := range s.List() { |
||||
v, ok := item.(int) |
||||
if !ok { |
||||
continue |
||||
} |
||||
|
||||
slice = append(slice, v) |
||||
} |
||||
return slice |
||||
} |
||||
@ -1,195 +0,0 @@ |
||||
package set |
||||
|
||||
import ( |
||||
"fmt" |
||||
"strings" |
||||
) |
||||
|
||||
// Provides a common set baseline for both threadsafe and non-ts Sets.
|
||||
type set struct { |
||||
m map[interface{}]struct{} // struct{} doesn't take up space
|
||||
} |
||||
|
||||
// SetNonTS defines a non-thread safe set data structure.
|
||||
type SetNonTS struct { |
||||
set |
||||
} |
||||
|
||||
// NewNonTS creates and initialize a new non-threadsafe Set.
|
||||
// It accepts a variable number of arguments to populate the initial set.
|
||||
// If nothing is passed a SetNonTS with zero size is created.
|
||||
func NewNonTS(items ...interface{}) *SetNonTS { |
||||
s := &SetNonTS{} |
||||
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 NewNonTS(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 |
||||
} |
||||
|
||||
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 |
||||
} |
||||
|
||||
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{} { |
||||
for item := range s.m { |
||||
delete(s.m, item) |
||||
return item |
||||
} |
||||
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 |
||||
} |
||||
|
||||
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 { |
||||
return len(s.m) |
||||
} |
||||
|
||||
// Clear removes all items from the set.
|
||||
func (s *set) Clear() { |
||||
s.m = make(map[interface{}]struct{}) |
||||
} |
||||
|
||||
// IsEmpty reports whether the Set is empty.
|
||||
func (s *set) IsEmpty() bool { |
||||
return s.Size() == 0 |
||||
} |
||||
|
||||
// IsEqual test whether s and t are the same in size and have the same items.
|
||||
func (s *set) IsEqual(t Interface) bool { |
||||
// 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) { |
||||
subset = true |
||||
|
||||
t.Each(func(item interface{}) bool { |
||||
_, subset = s.m[item] |
||||
return subset |
||||
}) |
||||
|
||||
return |
||||
} |
||||
|
||||
// IsSuperset tests whether t is a superset of s.
|
||||
func (s *set) IsSuperset(t Interface) bool { |
||||
return t.IsSubset(s) |
||||
} |
||||
|
||||
// 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) { |
||||
for item := range s.m { |
||||
if !f(item) { |
||||
break |
||||
} |
||||
} |
||||
} |
||||
|
||||
// String returns a string representation of s
|
||||
func (s *set) String() string { |
||||
t := make([]string, 0, len(s.List())) |
||||
for _, item := range s.List() { |
||||
t = append(t, fmt.Sprintf("%v", item)) |
||||
} |
||||
|
||||
return fmt.Sprintf("[%s]", strings.Join(t, ", ")) |
||||
} |
||||
|
||||
// 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{} { |
||||
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 NewNonTS(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) { |
||||
t.Each(func(item interface{}) bool { |
||||
s.m[item] = keyExists |
||||
return true |
||||
}) |
||||
} |
||||
|
||||
// it's not the opposite of Merge.
|
||||
// Separate removes the set items containing in t from set s. Please aware that
|
||||
func (s *set) Separate(t Interface) { |
||||
s.Remove(t.List()...) |
||||
} |
||||
@ -1,200 +0,0 @@ |
||||
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 |
||||
}) |
||||
} |
||||
Loading…
Reference in new issue