mirror of
https://github.com/hanzoai/tasks.git
synced 2026-10-04 02:04:03 +00:00
Alex ShtinandGitHub
8e8f1b0f7c
## What changed?
<!-- Describe what has changed in this PR -->
Remove license header from every file. Because it is really hard to
follow in this PR here is the summary:
1. License header is removed from all `.go` and `.proto` files
:fireworks::fireworks:🎆.
2. `LICENSE` file in the root directory has only Temporal and Uber
copyrights.
3. 5 other `LICENSE` files added to the packages which have copyrights
different from Temporal and Uber: Datadog, Xargin, "Mat Ryer, Tyler
Bunnell and contributors".
4. `license_file` flag is removed from all code generation tools.
5. `copyright_file` flag is removed from `go:generate mockgen`
directive.
6. All copyright related targets are removed from `Makefile`.
7. Updated Temporal copyright year to 2025 everywhere.
## Why?
<!-- Tell your future self why have you made these changes -->
I double checked with legal department that it is not needed to have
license header in every file. One file per repo is enough. I put all
copyrights to the root `LICENSE` file and removed header from all other
files. Also updated tools and `Makefile`.
68 lines
2.0 KiB
Go
68 lines
2.0 KiB
Go
package collection
|
|
|
|
import "slices"
|
|
|
|
// SortedSetManager provides CRUD functionality for in-memory sorted sets. Note that there's no Update method because
|
|
// you can just use the [SortedSetManager.Get] method and update that index directly.
|
|
type SortedSetManager[S ~[]E, E, K any] struct {
|
|
cmp func(E, K) int
|
|
key func(E) K
|
|
}
|
|
|
|
// NewSortedSetManager returns a new SortedSetManager with the given comparison function and key function.
|
|
func NewSortedSetManager[S ~[]E, E, K any](cmp func(E, K) int, key func(E) K) SortedSetManager[S, E, K] {
|
|
return SortedSetManager[S, E, K]{cmp, key}
|
|
}
|
|
|
|
// Add adds a new element to the set. If the element is already in the set, it returns the set unchanged and false.
|
|
func (m SortedSetManager[S, E, K]) Add(set S, e E) (S, bool) {
|
|
i, found := m.find(set, m.key(e))
|
|
if found {
|
|
return set, false
|
|
}
|
|
return slices.Insert(set, i, e), true
|
|
}
|
|
|
|
// Get returns the index of the element in the set that compares equal to key or -1 if no such element exists.
|
|
func (m SortedSetManager[S, E, K]) Get(set S, key K) int {
|
|
i, found := m.find(set, key)
|
|
if !found {
|
|
return -1
|
|
}
|
|
return i
|
|
}
|
|
|
|
// Paginate returns up to n elements in the set that compare greater than gtKey. If there are more than n such elements,
|
|
// it also returns the key of the last element in the page. Otherwise, the second return value is nil.
|
|
func (m SortedSetManager[S, E, K]) Paginate(set S, gtKey K, n int) (S, *K) {
|
|
i, exists := m.find(set, gtKey)
|
|
if exists {
|
|
i++
|
|
}
|
|
var (
|
|
lastKey *K
|
|
page S
|
|
)
|
|
if i+n >= len(set) {
|
|
page = set[i:]
|
|
} else {
|
|
tmp := m.key(set[i+n-1])
|
|
lastKey = &tmp
|
|
page = set[i : i+n]
|
|
}
|
|
return page, lastKey
|
|
}
|
|
|
|
// Remove removes an element from the set. If the element is not in the set, it returns the set unchanged and false.
|
|
func (m SortedSetManager[S, E, K]) Remove(set S, key K) (S, bool) {
|
|
i, found := m.find(set, key)
|
|
if !found {
|
|
return set, false
|
|
}
|
|
return slices.Delete(set, i, i+1), true
|
|
}
|
|
|
|
func (m SortedSetManager[S, E, K]) find(set S, key K) (int, bool) {
|
|
return slices.BinarySearchFunc(set, key, m.cmp)
|
|
}
|