2022-03-22 02:09:45 +01:00
|
|
|
// Copyright 2022 The Gitea Authors. All rights reserved.
|
2022-11-27 13:20:29 -05:00
|
|
|
// SPDX-License-Identifier: MIT
|
2022-03-22 02:09:45 +01:00
|
|
|
|
|
|
|
package util
|
|
|
|
|
2023-09-07 17:37:47 +08:00
|
|
|
import (
|
2024-01-19 12:37:10 +01:00
|
|
|
"cmp"
|
2023-09-07 17:37:47 +08:00
|
|
|
"slices"
|
|
|
|
"strings"
|
|
|
|
)
|
Improve utils of slices (#22379)
- Move the file `compare.go` and `slice.go` to `slice.go`.
- Fix `ExistsInSlice`, it's buggy
- It uses `sort.Search`, so it assumes that the input slice is sorted.
- It passes `func(i int) bool { return slice[i] == target })` to
`sort.Search`, that's incorrect, check the doc of `sort.Search`.
- Conbine `IsInt64InSlice(int64, []int64)` and `ExistsInSlice(string,
[]string)` to `SliceContains[T]([]T, T)`.
- Conbine `IsSliceInt64Eq([]int64, []int64)` and `IsEqualSlice([]string,
[]string)` to `SliceSortedEqual[T]([]T, T)`.
- Add `SliceEqual[T]([]T, T)` as a distinction from
`SliceSortedEqual[T]([]T, T)`.
- Redesign `RemoveIDFromList([]int64, int64) ([]int64, bool)` to
`SliceRemoveAll[T]([]T, T) []T`.
- Add `SliceContainsFunc[T]([]T, func(T) bool)` and
`SliceRemoveAllFunc[T]([]T, func(T) bool)` for general use.
- Add comments to explain why not `golang.org/x/exp/slices`.
- Add unit tests.
2023-01-11 13:31:16 +08:00
|
|
|
|
|
|
|
// SliceContainsString sequential searches if string exists in slice.
|
|
|
|
func SliceContainsString(slice []string, target string, insensitive ...bool) bool {
|
|
|
|
if len(insensitive) != 0 && insensitive[0] {
|
|
|
|
target = strings.ToLower(target)
|
2023-09-07 17:37:47 +08:00
|
|
|
return slices.ContainsFunc(slice, func(t string) bool { return strings.ToLower(t) == target })
|
Improve utils of slices (#22379)
- Move the file `compare.go` and `slice.go` to `slice.go`.
- Fix `ExistsInSlice`, it's buggy
- It uses `sort.Search`, so it assumes that the input slice is sorted.
- It passes `func(i int) bool { return slice[i] == target })` to
`sort.Search`, that's incorrect, check the doc of `sort.Search`.
- Conbine `IsInt64InSlice(int64, []int64)` and `ExistsInSlice(string,
[]string)` to `SliceContains[T]([]T, T)`.
- Conbine `IsSliceInt64Eq([]int64, []int64)` and `IsEqualSlice([]string,
[]string)` to `SliceSortedEqual[T]([]T, T)`.
- Add `SliceEqual[T]([]T, T)` as a distinction from
`SliceSortedEqual[T]([]T, T)`.
- Redesign `RemoveIDFromList([]int64, int64) ([]int64, bool)` to
`SliceRemoveAll[T]([]T, T) []T`.
- Add `SliceContainsFunc[T]([]T, func(T) bool)` and
`SliceRemoveAllFunc[T]([]T, func(T) bool)` for general use.
- Add comments to explain why not `golang.org/x/exp/slices`.
- Add unit tests.
2023-01-11 13:31:16 +08:00
|
|
|
}
|
|
|
|
|
2023-09-07 17:37:47 +08:00
|
|
|
return slices.Contains(slice, target)
|
Improve utils of slices (#22379)
- Move the file `compare.go` and `slice.go` to `slice.go`.
- Fix `ExistsInSlice`, it's buggy
- It uses `sort.Search`, so it assumes that the input slice is sorted.
- It passes `func(i int) bool { return slice[i] == target })` to
`sort.Search`, that's incorrect, check the doc of `sort.Search`.
- Conbine `IsInt64InSlice(int64, []int64)` and `ExistsInSlice(string,
[]string)` to `SliceContains[T]([]T, T)`.
- Conbine `IsSliceInt64Eq([]int64, []int64)` and `IsEqualSlice([]string,
[]string)` to `SliceSortedEqual[T]([]T, T)`.
- Add `SliceEqual[T]([]T, T)` as a distinction from
`SliceSortedEqual[T]([]T, T)`.
- Redesign `RemoveIDFromList([]int64, int64) ([]int64, bool)` to
`SliceRemoveAll[T]([]T, T) []T`.
- Add `SliceContainsFunc[T]([]T, func(T) bool)` and
`SliceRemoveAllFunc[T]([]T, func(T) bool)` for general use.
- Add comments to explain why not `golang.org/x/exp/slices`.
- Add unit tests.
2023-01-11 13:31:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// SliceSortedEqual returns true if the two slices will be equal when they get sorted.
|
|
|
|
// It doesn't require that the slices have been sorted, and it doesn't sort them either.
|
|
|
|
func SliceSortedEqual[T comparable](s1, s2 []T) bool {
|
|
|
|
if len(s1) != len(s2) {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
|
|
|
|
counts := make(map[T]int, len(s1))
|
|
|
|
for _, v := range s1 {
|
|
|
|
counts[v]++
|
|
|
|
}
|
|
|
|
for _, v := range s2 {
|
|
|
|
counts[v]--
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, v := range counts {
|
|
|
|
if v != 0 {
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
|
|
|
|
// SliceRemoveAll removes all the target elements from the slice.
|
|
|
|
func SliceRemoveAll[T comparable](slice []T, target T) []T {
|
2023-09-07 17:37:47 +08:00
|
|
|
return slices.DeleteFunc(slice, func(t T) bool { return t == target })
|
2022-03-22 02:09:45 +01:00
|
|
|
}
|
2024-01-19 12:37:10 +01:00
|
|
|
|
|
|
|
// Sorted returns the sorted slice
|
|
|
|
// Note: The parameter is sorted inline.
|
|
|
|
func Sorted[S ~[]E, E cmp.Ordered](values S) S {
|
|
|
|
slices.Sort(values)
|
|
|
|
return values
|
|
|
|
}
|
2024-03-12 12:57:19 +08:00
|
|
|
|
2024-03-21 21:13:08 +08:00
|
|
|
// TODO: Replace with "maps.Values" once available, current it only in golang.org/x/exp/maps but not in standard library
|
2024-03-12 12:57:19 +08:00
|
|
|
func ValuesOfMap[K comparable, V any](m map[K]V) []V {
|
|
|
|
values := make([]V, 0, len(m))
|
|
|
|
for _, v := range m {
|
|
|
|
values = append(values, v)
|
|
|
|
}
|
|
|
|
return values
|
|
|
|
}
|
2024-03-21 21:13:08 +08:00
|
|
|
|
|
|
|
// TODO: Replace with "maps.Keys" once available, current it only in golang.org/x/exp/maps but not in standard library
|
|
|
|
func KeysOfMap[K comparable, V any](m map[K]V) []K {
|
|
|
|
keys := make([]K, 0, len(m))
|
|
|
|
for k := range m {
|
|
|
|
keys = append(keys, k)
|
|
|
|
}
|
|
|
|
return keys
|
|
|
|
}
|