vendor tsgo

tools/tsgo/internal/collections/set.go

@@ -0,0 +1,144 @@
+package collections
+
+import "maps"
+
+type Set[T comparable] struct {
+	M map[T]struct{}
+}
+
+// NewSetWithSizeHint creates a new Set with a hint for the number of elements it will contain.
+func NewSetWithSizeHint[T comparable](hint int) *Set[T] {
+	return &Set[T]{
+		M: make(map[T]struct{}, hint),
+	}
+}
+
+func (s *Set[T]) Has(key T) bool {
+	if s == nil {
+		return false
+	}
+	_, ok := s.M[key]
+	return ok
+}
+
+func (s *Set[T]) Add(key T) {
+	if s.M == nil {
+		s.M = make(map[T]struct{})
+	}
+	s.M[key] = struct{}{}
+}
+
+func (s *Set[T]) Delete(key T) {
+	delete(s.M, key)
+}
+
+func (s *Set[T]) Len() int {
+	if s == nil {
+		return 0
+	}
+	return len(s.M)
+}
+
+func (s *Set[T]) Keys() map[T]struct{} {
+	if s == nil {
+		return nil
+	}
+	return s.M
+}
+
+func (s *Set[T]) Clear() {
+	if s == nil {
+		return
+	}
+	clear(s.M)
+}
+
+// Returns true if the key was not already present in the set.
+func (s *Set[T]) AddIfAbsent(key T) bool {
+	if s.Has(key) {
+		return false
+	}
+	s.Add(key)
+	return true
+}
+
+func (s *Set[T]) Clone() *Set[T] {
+	if s == nil {
+		return nil
+	}
+	clone := &Set[T]{M: maps.Clone(s.M)}
+	return clone
+}
+
+func (s *Set[T]) Union(other *Set[T]) {
+	if s.Len() == 0 && other.Len() == 0 {
+		return
+	}
+	if s == nil {
+		panic("cannot modify nil Set")
+	}
+	if s.M == nil {
+		s.M = maps.Clone(other.M)
+		return
+	}
+	maps.Copy(s.M, other.M)
+}
+
+func (s *Set[T]) UnionedWith(other *Set[T]) *Set[T] {
+	if s == nil && other == nil {
+		return nil
+	}
+	result := s.Clone()
+	if other != nil {
+		if result == nil {
+			result = &Set[T]{}
+		}
+		if result.M == nil {
+			result.M = make(map[T]struct{}, len(other.M))
+		}
+		maps.Copy(result.M, other.M)
+	}
+	return result
+}
+
+func (s *Set[T]) Equals(other *Set[T]) bool {
+	if s == other {
+		return true
+	}
+	if s == nil || other == nil {
+		return false
+	}
+	return maps.Equal(s.M, other.M)
+}
+
+func (s *Set[T]) IsSubsetOf(other *Set[T]) bool {
+	if s == nil {
+		return true
+	}
+	for key := range s.M {
+		if !other.Has(key) {
+			return false
+		}
+	}
+	return true
+}
+
+func (s *Set[T]) Intersects(other *Set[T]) bool {
+	if s == nil || other == nil {
+		return false
+	}
+	for key := range s.M {
+		if other.Has(key) {
+			return true
+		}
+	}
+	return false
+}
+
+func NewSetFromItems[T comparable](items ...T) *Set[T] {
+	s := &Set[T]{}
+	for _, item := range items {
+		s.Add(item)
+	}
+	return s
+}