add sets data structure

Author: leopoldxx

ds/sets/stringset.go

@@ -0,0 +1,219 @@
+package sets
+
+import (
+	"sort"
+	"sync"
+)
+
+// StringSet operations for string keys
+type StringSet interface {
+	Insert(items ...string)
+	Delete(items ...string)
+	Clear() []string
+	Replace(items ...string)
+	Has(item string) bool
+	HasAll(items ...string) bool
+	HasAny(items ...string) bool
+	IsSuperset(right StringSet) bool
+	IsSubset(right StringSet) bool
+	Equal(right StringSet) bool
+	Diff(right StringSet) StringSet
+	Union(right StringSet) StringSet
+	Intersection(right StringSet) StringSet
+	List() []string
+	SortedList() []string
+	PopAny() (string, bool)
+	Len() int
+}
+
+// NewStringSet create a StringSet from a string slice
+func NewStringSet(items ...string) StringSet {
+	ss := &ssetImpl{
+		set:   make(map[string]struct{}),
+		mutex: new(sync.RWMutex),
+	}
+	if len(items) > 0 {
+		ss.Insert(items...)
+	}
+	return ss
+}
+
+type ssetImpl struct {
+	set   map[string]struct{}
+	mutex *sync.RWMutex
+}
+
+func (ss *ssetImpl) Insert(items ...string) {
+	ss.mutex.Lock()
+	defer ss.mutex.Unlock()
+
+	for _, item := range items {
+		ss.set[item] = struct{}{}
+	}
+}
+func (ss *ssetImpl) Delete(items ...string) {
+	ss.mutex.Lock()
+	defer ss.mutex.Unlock()
+
+	for _, item := range items {
+		delete(ss.set, item)
+	}
+}
+
+func (ss *ssetImpl) Clear() []string {
+	ss.mutex.Lock()
+	defer ss.mutex.Unlock()
+
+	result := make([]string, 0, len(ss.set))
+	for item := range ss.set {
+		result = append(result, item)
+	}
+	// use a new map to replace with the old one, and the old one will be gced.
+	ss.set = make(map[string]struct{})
+
+	return result
+}
+func (ss *ssetImpl) Replace(items ...string) {
+	ss.mutex.Lock()
+	defer ss.mutex.Unlock()
+
+	// use a new map to replace with the old one, and the old one will be gced.
+	ss.set = make(map[string]struct{})
+	for _, item := range items {
+		ss.set[item] = struct{}{}
+	}
+}
+func (ss *ssetImpl) Has(item string) bool {
+	ss.mutex.RLock()
+	defer ss.mutex.RUnlock()
+
+	return ss.hasImpl(item)
+}
+func (ss *ssetImpl) hasImpl(item string) bool {
+	_, exists := ss.set[item]
+	return exists
+}
+
+func (ss *ssetImpl) HasAll(items ...string) bool {
+	ss.mutex.RLock()
+	defer ss.mutex.RUnlock()
+
+	for _, item := range items {
+		if !ss.hasImpl(item) {
+			return false
+		}
+	}
+	return true
+}
+func (ss *ssetImpl) HasAny(items ...string) bool {
+	ss.mutex.RLock()
+	defer ss.mutex.RUnlock()
+
+	for _, item := range items {
+		if ss.hasImpl(item) {
+			return true
+		}
+	}
+	return false
+}
+func (ss *ssetImpl) IsSuperset(right StringSet) bool {
+	rightImpl := right.(*ssetImpl)
+
+	ss.mutex.RLock()
+	rightImpl.mutex.RLock()
+	defer ss.mutex.RUnlock()
+	defer rightImpl.mutex.RUnlock()
+
+	for item := range rightImpl.set {
+		if !ss.hasImpl(item) {
+			return false
+		}
+	}
+	return true
+}
+func (ss *ssetImpl) IsSubset(right StringSet) bool {
+	return right.IsSuperset(ss)
+}
+func (ss *ssetImpl) Equal(right StringSet) bool {
+	return ss.Len() == right.Len() && ss.IsSuperset(right)
+}
+func (ss *ssetImpl) Diff(right StringSet) StringSet {
+	ss.mutex.RLock()
+	defer ss.mutex.RUnlock()
+
+	result := NewStringSet()
+	for item := range ss.set {
+		if !right.Has(item) {
+			result.Insert(item)
+		}
+	}
+	return result
+}
+func (ss *ssetImpl) Union(right StringSet) StringSet {
+	rightImpl := right.(*ssetImpl)
+
+	ss.mutex.RLock()
+	rightImpl.mutex.RLock()
+	defer ss.mutex.RUnlock()
+	defer rightImpl.mutex.RUnlock()
+
+	result := NewStringSet()
+	for item := range ss.set {
+		result.Insert(item)
+	}
+	for item := range rightImpl.set {
+		result.Insert(item)
+	}
+	return result
+}
+func (ss *ssetImpl) Intersection(right StringSet) StringSet {
+	s1 := ss
+	s2 := right.(*ssetImpl)
+	if s1.Len() > s2.Len() {
+		s1, s2 = s2, s1
+	}
+
+	s1.mutex.RLock()
+	s2.mutex.RLock()
+	defer s1.mutex.RUnlock()
+	defer s2.mutex.RUnlock()
+
+	result := NewStringSet()
+	for item := range s1.set {
+		if s2.hasImpl(item) {
+			result.Insert(item)
+		}
+	}
+	return result
+}
+func (ss *ssetImpl) List() []string {
+	ss.mutex.RLock()
+	defer ss.mutex.RUnlock()
+
+	result := make([]string, 0, len(ss.set))
+	for item := range ss.set {
+		result = append(result, item)
+	}
+	return result
+}
+func (ss *ssetImpl) SortedList() []string {
+	list := ss.List()
+	sort.Strings(list)
+	return list
+}
+func (ss *ssetImpl) PopAny() (string, bool) {
+	ss.mutex.Lock()
+	defer ss.mutex.Unlock()
+
+	for item := range ss.set {
+		delete(ss.set, item)
+		return item, true
+	}
+	return "", false
+}
+func (ss *ssetImpl) Len() int {
+	ss.mutex.RLock()
+	defer ss.mutex.RUnlock()
+
+	return len(ss.set)
+}

ds/sets/stringset_test.go

@@ -0,0 +1,80 @@
+package sets_test
+
+import (
+	"testing"
+
+	"github.com/leopoldxx/go-utils/ds/sets"
+)
+
+func TestStringSet(t *testing.T) {
+	left := sets.NewStringSet("a", "b", "c", "d", "e")
+	right := sets.NewStringSet("d", "e", "f", "g", "h")
+	right2 := sets.NewStringSet("a", "b", "f", "n", "m")
+
+	if !left.Diff(right.Union(right2)).Equal(sets.NewStringSet("c")) {
+		t.Fatal("should equal")
+	}
+
+	if !left.Has("a") {
+		t.Fatal("should have 'a'")
+	}
+
+	if left.Len() != right.Len() || left.Len() != 5 || len(left.List()) != len(left.SortedList()) {
+		t.Fatal("not same length")
+	}
+
+	res := left.Diff(right)
+	if !res.Equal(sets.NewStringSet("a", "b", "c")) {
+		t.Fatal("invalid diff: %v", res)
+	}
+
+	res = right.Diff(left)
+	if !res.Equal(sets.NewStringSet("f", "g", "h")) {
+		t.Fatal("invalid diff: %v", res)
+	}
+
+	if !left.Intersection(right).Equal(sets.NewStringSet("d", "e")) {
+		t.Fatal("invalid intersection: %v", res)
+	}
+
+	left.Delete("a")
+
+	if left.Has("a") {
+		t.Fatal("should not have 'a'")
+	}
+
+	if !left.HasAll("b", "c", "d", "e") {
+		t.Fatal("should have all")
+	}
+
+	if !left.HasAny("b", "c", "m", "n") {
+		t.Fatal("should have any")
+	}
+
+	if !left.Union(right).Equal(sets.NewStringSet("b", "c", "d", "e", "f", "g", "h")) {
+		t.Fatal("invalid union")
+	}
+
+	if !left.IsSuperset(sets.NewStringSet("c", "d")) {
+		t.Fatal("invalid superset")
+	}
+
+	left.PopAny()
+	if left.Len() != 3 {
+		t.Fatal("invalid popany")
+	}
+
+	_, ok := left.PopAny()
+	for ok {
+		_, ok = left.PopAny()
+	}
+	if left.Len() != 0 {
+		t.Fatal("invalid popany2")
+	}
+	t.Logf("%v", left)
+	left.Replace(right.List()...)
+	t.Logf("%v", left)
+	if !left.Equal(right) {
+		t.Fatal("should equal")
+	}
+}