86 lines
2.2 KiB
Go
86 lines
2.2 KiB
Go
package utils
|
|
|
|
import (
|
|
"reflect"
|
|
"sort"
|
|
)
|
|
|
|
func AppendEmptySliceField(slice reflect.Value) reflect.Value {
|
|
newField := reflect.Zero(slice.Type().Elem())
|
|
return reflect.Append(slice, newField)
|
|
}
|
|
|
|
func SetSliceLengh(slice reflect.Value, length int) reflect.Value {
|
|
if length > slice.Len() {
|
|
for i := slice.Len(); i < length; i++ {
|
|
slice = AppendEmptySliceField(slice)
|
|
}
|
|
} else if length < slice.Len() {
|
|
slice = slice.Slice(0, length)
|
|
}
|
|
|
|
return slice
|
|
}
|
|
|
|
func DeleteEmptySliceElementsVal(sliceVal reflect.Value) reflect.Value {
|
|
if sliceVal.Kind() != reflect.Slice {
|
|
panic("Argument is not a slice: " + sliceVal.String())
|
|
}
|
|
zeroVal := reflect.Zero(sliceVal.Type().Elem())
|
|
for i := 0; i < sliceVal.Len(); i++ {
|
|
elemVal := sliceVal.Index(i)
|
|
if reflect.DeepEqual(elemVal.Interface(), zeroVal.Interface()) {
|
|
before := sliceVal.Slice(0, i)
|
|
after := sliceVal.Slice(i+1, sliceVal.Len())
|
|
sliceVal = reflect.AppendSlice(before, after)
|
|
i--
|
|
}
|
|
}
|
|
return sliceVal
|
|
}
|
|
|
|
func DeleteEmptySliceElements(slice interface{}) interface{} {
|
|
return DeleteEmptySliceElementsVal(reflect.ValueOf(slice)).Interface()
|
|
}
|
|
|
|
func DeleteSliceElementVal(sliceVal reflect.Value, idx int) reflect.Value {
|
|
if idx < 0 || idx >= sliceVal.Len() {
|
|
return sliceVal
|
|
}
|
|
before := sliceVal.Slice(0, idx)
|
|
after := sliceVal.Slice(idx+1, sliceVal.Len())
|
|
sliceVal = reflect.AppendSlice(before, after)
|
|
return sliceVal
|
|
}
|
|
|
|
func DeleteSliceElement(slice interface{}, idx int) interface{} {
|
|
return DeleteSliceElementVal(reflect.ValueOf(slice), idx).Interface()
|
|
}
|
|
|
|
// Implements sort.Interface
|
|
type SortableInterfaceSlice struct {
|
|
Slice []interface{}
|
|
LessFunc func(a, b interface{}) bool
|
|
}
|
|
|
|
func (self *SortableInterfaceSlice) Len() int {
|
|
return len(self.Slice)
|
|
}
|
|
|
|
func (self *SortableInterfaceSlice) Less(i, j int) bool {
|
|
return self.LessFunc(self.Slice[i], self.Slice[j])
|
|
}
|
|
|
|
func (self *SortableInterfaceSlice) Swap(i, j int) {
|
|
self.Slice[i], self.Slice[j] = self.Slice[j], self.Slice[i]
|
|
}
|
|
|
|
func (self *SortableInterfaceSlice) Sort() {
|
|
sort.Sort(self)
|
|
}
|
|
|
|
func SortInterfaceSlice(slice []interface{}, lessFunc func(a, b interface{}) bool) {
|
|
sortable := SortableInterfaceSlice{slice, lessFunc}
|
|
sortable.Sort()
|
|
}
|