kubernetes/staging/src/k8s.io/apimachinery/pkg/util/sets/set.go

type Set …

// cast transforms specified set to generic Set[T].
func cast[T comparable](s map[T]Empty) Set[T] { … }

// New creates a Set from a list of values.
// NOTE: type param must be explicitly instantiated if given items are empty.
func New[T comparable](items ...T) Set[T] { … }

// KeySet creates a Set from a keys of a map[comparable](? extends interface{}).
// If the value passed in is not actually a map, this will panic.
func KeySet[T comparable, V any](theMap map[T]V) Set[T] { … }

// Insert adds items to the set.
func (s Set[T]) Insert(items ...T) Set[T] { … }

func Insert[T comparable](set Set[T], items ...T) Set[T] { … }

// Delete removes all items from the set.
func (s Set[T]) Delete(items ...T) Set[T] { … }

// Clear empties the set.
// It is preferable to replace the set with a newly constructed set,
// but not all callers can do that (when there are other references to the map).
func (s Set[T]) Clear() Set[T] { … }

// Has returns true if and only if item is contained in the set.
func (s Set[T]) Has(item T) bool { … }

// HasAll returns true if and only if all items are contained in the set.
func (s Set[T]) HasAll(items ...T) bool { … }

// HasAny returns true if any items are contained in the set.
func (s Set[T]) HasAny(items ...T) bool { … }

// Clone returns a new set which is a copy of the current set.
func (s Set[T]) Clone() Set[T] { … }

// Difference returns a set of objects that are not in s2.
// For example:
// s1 = {a1, a2, a3}
// s2 = {a1, a2, a4, a5}
// s1.Difference(s2) = {a3}
// s2.Difference(s1) = {a4, a5}
func (s1 Set[T]) Difference(s2 Set[T]) Set[T] { … }

// SymmetricDifference returns a set of elements which are in either of the sets, but not in their intersection.
// For example:
// s1 = {a1, a2, a3}
// s2 = {a1, a2, a4, a5}
// s1.SymmetricDifference(s2) = {a3, a4, a5}
// s2.SymmetricDifference(s1) = {a3, a4, a5}
func (s1 Set[T]) SymmetricDifference(s2 Set[T]) Set[T] { … }

// Union returns a new set which includes items in either s1 or s2.
// For example:
// s1 = {a1, a2}
// s2 = {a3, a4}
// s1.Union(s2) = {a1, a2, a3, a4}
// s2.Union(s1) = {a1, a2, a3, a4}
func (s1 Set[T]) Union(s2 Set[T]) Set[T] { … }

// Intersection returns a new set which includes the item in BOTH s1 and s2
// For example:
// s1 = {a1, a2}
// s2 = {a2, a3}
// s1.Intersection(s2) = {a2}
func (s1 Set[T]) Intersection(s2 Set[T]) Set[T] { … }

// IsSuperset returns true if and only if s1 is a superset of s2.
func (s1 Set[T]) IsSuperset(s2 Set[T]) bool { … }

// Equal returns true if and only if s1 is equal (as a set) to s2.
// Two sets are equal if their membership is identical.
// (In practice, this means same elements, order doesn't matter)
func (s1 Set[T]) Equal(s2 Set[T]) bool { … }

type sortableSliceOfGeneric …

func (g sortableSliceOfGeneric[T]) Len() int           { … }

func (g sortableSliceOfGeneric[T]) Less(i, j int) bool { … }

func (g sortableSliceOfGeneric[T]) Swap(i, j int)      { … }

// List returns the contents as a sorted T slice.
//
// This is a separate function and not a method because not all types supported
// by Generic are ordered and only those can be sorted.
func List[T cmp.Ordered](s Set[T]) []T { … }

// UnsortedList returns the slice with contents in random order.
func (s Set[T]) UnsortedList() []T { … }

// PopAny returns a single element from the set.
func (s Set[T]) PopAny() (T, bool) { … }

// Len returns the size of the set.
func (s Set[T]) Len() int { … }

func less[T cmp.Ordered](lhs, rhs T) bool { … }