mirror of
https://codeberg.org/forgejo/forgejo
synced 2025-10-19 06:20:45 +02:00
100 lines
2.1 KiB
Go
100 lines
2.1 KiB
Go
// Copyright 2022 The Gitea Authors. All rights reserved.
|
|
// SPDX-License-Identifier: MIT
|
|
|
|
package container
|
|
|
|
import (
|
|
"iter"
|
|
"maps"
|
|
)
|
|
|
|
type Set[T comparable] map[T]struct{}
|
|
|
|
// SetOf creates a set and adds the specified elements to it.
|
|
func SetOf[T comparable](values ...T) Set[T] {
|
|
s := make(Set[T], len(values))
|
|
s.AddMultiple(values...)
|
|
return s
|
|
}
|
|
|
|
// Add adds the specified element to a set.
|
|
// Returns true if the element is added; false if the element is already present.
|
|
func (s Set[T]) Add(value T) bool {
|
|
if _, has := s[value]; !has {
|
|
s[value] = struct{}{}
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// AddMultiple adds the specified elements to a set.
|
|
func (s Set[T]) AddMultiple(values ...T) {
|
|
for _, value := range values {
|
|
s.Add(value)
|
|
}
|
|
}
|
|
|
|
func (s Set[T]) IsSubset(subset []T) bool {
|
|
for _, v := range subset {
|
|
if !s.Contains(v) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Contains determines whether a set contains the specified element.
|
|
// Returns true if the set contains the specified element; otherwise, false.
|
|
func (s Set[T]) Contains(value T) bool {
|
|
_, has := s[value]
|
|
return has
|
|
}
|
|
|
|
// Remove removes the specified element.
|
|
// Returns true if the element is successfully found and removed; otherwise, false.
|
|
func (s Set[T]) Remove(value T) bool {
|
|
if _, has := s[value]; has {
|
|
delete(s, value)
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// Values gets a list of all elements in the set.
|
|
func (s Set[T]) Values() []T {
|
|
keys := make([]T, 0, len(s))
|
|
for k := range s {
|
|
keys = append(keys, k)
|
|
}
|
|
return keys
|
|
}
|
|
|
|
// Seq returns a iterator over the elements in the set.
|
|
// It returns a single-use iterator.
|
|
func (s Set[T]) Seq() iter.Seq[T] {
|
|
return maps.Keys(s)
|
|
}
|
|
|
|
// Clone returns a identical shallow copy of this set.
|
|
func (s Set[T]) Clone() Set[T] {
|
|
return maps.Clone(s)
|
|
}
|
|
|
|
// Computes the elements that are in this set, that aren't in the other set.
|
|
func (s Set[T]) Difference(other Set[T]) Set[T] {
|
|
result := make(Set[T])
|
|
for key := range s {
|
|
if !other.Contains(key) {
|
|
result.Add(key)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func (s Set[T]) Slice() []T {
|
|
retval := make([]T, 0, len(s))
|
|
for key := range s {
|
|
retval = append(retval, key)
|
|
}
|
|
return retval
|
|
}
|