Курнат Андрей
135 lines
3.3 KiB
Go
135 lines
3.3 KiB
Go
package tw
|
|
|
|
import "slices"
|
|
|
|
// Slicer is a generic slice type that provides additional methods for slice manipulation.
|
|
type Slicer[T any] []T
|
|
|
|
// NewSlicer creates and returns a new initialized Slicer.
|
|
func NewSlicer[T any]() Slicer[T] {
|
|
return make(Slicer[T], 0)
|
|
}
|
|
|
|
// Get returns the element at the specified index.
|
|
// Returns the zero value if the index is out of bounds or the slice is nil.
|
|
func (s Slicer[T]) Get(index int) T {
|
|
if s == nil || index < 0 || index >= len(s) {
|
|
var zero T
|
|
return zero
|
|
}
|
|
return s[index]
|
|
}
|
|
|
|
// GetOK returns the element at the specified index and a boolean indicating whether the index was valid.
|
|
func (s Slicer[T]) GetOK(index int) (T, bool) {
|
|
if s == nil || index < 0 || index >= len(s) {
|
|
var zero T
|
|
return zero, false
|
|
}
|
|
return s[index], true
|
|
}
|
|
|
|
// Append appends elements to the slice and returns the new slice.
|
|
func (s Slicer[T]) Append(elements ...T) Slicer[T] {
|
|
return append(s, elements...)
|
|
}
|
|
|
|
// Prepend adds elements to the beginning of the slice and returns the new slice.
|
|
func (s Slicer[T]) Prepend(elements ...T) Slicer[T] {
|
|
return append(elements, s...)
|
|
}
|
|
|
|
// Len returns the number of elements in the slice.
|
|
// Returns 0 if the slice is nil.
|
|
func (s Slicer[T]) Len() int {
|
|
if s == nil {
|
|
return 0
|
|
}
|
|
return len(s)
|
|
}
|
|
|
|
// IsEmpty returns true if the slice is nil or has zero elements.
|
|
func (s Slicer[T]) IsEmpty() bool {
|
|
return s.Len() == 0
|
|
}
|
|
|
|
// Has returns true if the index exists in the slice.
|
|
func (s Slicer[T]) Has(index int) bool {
|
|
return index >= 0 && index < s.Len()
|
|
}
|
|
|
|
// First returns the first element of the slice, or the zero value if empty.
|
|
func (s Slicer[T]) First() T {
|
|
return s.Get(0)
|
|
}
|
|
|
|
// Last returns the last element of the slice, or the zero value if empty.
|
|
func (s Slicer[T]) Last() T {
|
|
return s.Get(s.Len() - 1)
|
|
}
|
|
|
|
// Each iterates over each element in the slice and calls the provided function.
|
|
// Does nothing if the slice is nil.
|
|
func (s Slicer[T]) Each(fn func(T)) {
|
|
for _, v := range s {
|
|
fn(v)
|
|
}
|
|
}
|
|
|
|
// Filter returns a new Slicer containing only elements that satisfy the predicate.
|
|
func (s Slicer[T]) Filter(fn func(T) bool) Slicer[T] {
|
|
result := NewSlicer[T]()
|
|
for _, v := range s {
|
|
if fn(v) {
|
|
result = result.Append(v)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Map returns a new Slicer with each element transformed by the provided function.
|
|
func (s Slicer[T]) Map(fn func(T) T) Slicer[T] {
|
|
result := NewSlicer[T]()
|
|
for _, v := range s {
|
|
result = result.Append(fn(v))
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Contains returns true if the slice contains an element that satisfies the predicate.
|
|
func (s Slicer[T]) Contains(fn func(T) bool) bool {
|
|
return slices.ContainsFunc(s, fn)
|
|
}
|
|
|
|
// Find returns the first element that satisfies the predicate, along with a boolean indicating if it was found.
|
|
func (s Slicer[T]) Find(fn func(T) bool) (T, bool) {
|
|
for _, v := range s {
|
|
if fn(v) {
|
|
return v, true
|
|
}
|
|
}
|
|
var zero T
|
|
return zero, false
|
|
}
|
|
|
|
// Clone returns a shallow copy of the Slicer.
|
|
func (s Slicer[T]) Clone() Slicer[T] {
|
|
result := NewSlicer[T]()
|
|
if s != nil {
|
|
result = append(result, s...)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// SlicerToMapper converts a Slicer of KeyValuePair to a Mapper.
|
|
func SlicerToMapper[K comparable, V any](s Slicer[KeyValuePair[K, V]]) Mapper[K, V] {
|
|
result := make(Mapper[K, V])
|
|
if s == nil {
|
|
return result
|
|
}
|
|
for _, pair := range s {
|
|
result[pair.Key] = pair.Value
|
|
}
|
|
return result
|
|
}
|