init

vendor/github.com/anacrolix/missinggo/slices/cast.go

@@ -0,0 +1,46 @@
+package slices
+
+import (
+	"reflect"
+
+	"github.com/bradfitz/iter"
+)
+
+// Returns a copy of all the elements of slice []T as a slice of interface{}.
+func ToEmptyInterface(slice interface{}) (ret []interface{}) {
+	v := reflect.ValueOf(slice)
+	l := v.Len()
+	ret = make([]interface{}, 0, l)
+	for i := range iter.N(v.Len()) {
+		ret = append(ret, v.Index(i).Interface())
+	}
+	return
+}
+
+// Makes and sets a slice at *ptrTo, and type asserts all the elements from
+// from to it.
+func MakeInto(ptrTo interface{}, from interface{}) {
+	fromSliceValue := reflect.ValueOf(from)
+	fromLen := fromSliceValue.Len()
+	if fromLen == 0 {
+		return
+	}
+	// Deref the pointer to slice.
+	slicePtrValue := reflect.ValueOf(ptrTo)
+	if slicePtrValue.Kind() != reflect.Ptr {
+		panic("destination is not a pointer")
+	}
+	destSliceValue := slicePtrValue.Elem()
+	// The type of the elements of the destination slice.
+	destSliceElemType := destSliceValue.Type().Elem()
+	destSliceValue.Set(reflect.MakeSlice(destSliceValue.Type(), fromLen, fromLen))
+	for i := range iter.N(fromSliceValue.Len()) {
+		// The value inside the interface in the slice element.
+		itemValue := fromSliceValue.Index(i)
+		if itemValue.Kind() == reflect.Interface {
+			itemValue = itemValue.Elem()
+		}
+		convertedItem := itemValue.Convert(destSliceElemType)
+		destSliceValue.Index(i).Set(convertedItem)
+	}
+}

vendor/github.com/anacrolix/missinggo/slices/doc.go

@@ -0,0 +1,5 @@
+// Package slices has several utilities for operating on slices given Go's
+// lack of generic types. Many functions take an argument of type func(l, r T)
+// bool, that's expected to compute l < r where T is T in []T, the type of the
+// given slice.
+package slices

vendor/github.com/anacrolix/missinggo/slices/filter.go

@@ -0,0 +1,17 @@
+package slices
+
+import "reflect"
+
+// sl []T, f is func(*T) bool.
+func FilterInPlace(sl interface{}, f interface{}) {
+	v := reflect.ValueOf(sl).Elem()
+	j := 0
+	for i := 0; i < v.Len(); i++ {
+		e := v.Index(i)
+		if reflect.ValueOf(f).Call([]reflect.Value{e.Addr()})[0].Bool() {
+			v.Index(j).Set(e)
+			j++
+		}
+	}
+	v.SetLen(j)
+}

vendor/github.com/anacrolix/missinggo/slices/map.go

@@ -0,0 +1,49 @@
+package slices
+
+import "reflect"
+
+type MapItem struct {
+	Key, Elem interface{}
+}
+
+// Creates a []struct{Key K; Value V} for map[K]V.
+func FromMap(m interface{}) (slice []MapItem) {
+	mapValue := reflect.ValueOf(m)
+	for _, key := range mapValue.MapKeys() {
+		slice = append(slice, MapItem{key.Interface(), mapValue.MapIndex(key).Interface()})
+	}
+	return
+}
+
+// Returns all the elements []T, from m where m is map[K]T.
+func FromMapElems(m interface{}) interface{} {
+	inValue := reflect.ValueOf(m)
+	outValue := reflect.MakeSlice(reflect.SliceOf(inValue.Type().Elem()), inValue.Len(), inValue.Len())
+	for i, key := range inValue.MapKeys() {
+		outValue.Index(i).Set(inValue.MapIndex(key))
+	}
+	return outValue.Interface()
+}
+
+// Returns all the elements []K, from m where m is map[K]T.
+func FromMapKeys(m interface{}) interface{} {
+	inValue := reflect.ValueOf(m)
+	outValue := reflect.MakeSlice(reflect.SliceOf(inValue.Type().Key()), inValue.Len(), inValue.Len())
+	for i, key := range inValue.MapKeys() {
+		outValue.Index(i).Set(key)
+	}
+	return outValue.Interface()
+}
+
+// f: (T)T, input: []T, outout: []T
+func Map(f, input interface{}) interface{} {
+	inputValue := reflect.ValueOf(input)
+	funcValue := reflect.ValueOf(f)
+	_len := inputValue.Len()
+	retValue := reflect.MakeSlice(reflect.TypeOf(input), _len, _len)
+	for i := 0; i < _len; i++ {
+		out := funcValue.Call([]reflect.Value{inputValue.Index(i)})
+		retValue.Index(i).Set(out[0])
+	}
+	return retValue.Interface()
+}

vendor/github.com/anacrolix/missinggo/slices/sort.go

@@ -0,0 +1,36 @@
+package slices
+
+import (
+	"container/heap"
+	"reflect"
+	"sort"
+)
+
+// Sorts the slice in place. Returns sl for convenience.
+func Sort(sl interface{}, less interface{}) interface{} {
+	sorter := sorter{
+		sl:   reflect.ValueOf(sl),
+		less: reflect.ValueOf(less),
+	}
+	sort.Sort(&sorter)
+	return sorter.sl.Interface()
+}
+
+// Creates a modifiable copy of a slice reference. Because you can't modify
+// non-pointer types inside an interface{}.
+func addressableSlice(slice interface{}) reflect.Value {
+	v := reflect.ValueOf(slice)
+	p := reflect.New(v.Type())
+	p.Elem().Set(v)
+	return p.Elem()
+}
+
+// Returns a "container/heap".Interface for the provided slice.
+func HeapInterface(sl interface{}, less interface{}) heap.Interface {
+	ret := &sorter{
+		sl:   addressableSlice(sl),
+		less: reflect.ValueOf(less),
+	}
+	heap.Init(ret)
+	return ret
+}

vendor/github.com/anacrolix/missinggo/slices/sorter.go

@@ -0,0 +1,36 @@
+package slices
+
+import "reflect"
+
+type sorter struct {
+	sl   reflect.Value
+	less reflect.Value
+}
+
+func (s *sorter) Len() int {
+	return s.sl.Len()
+}
+
+func (s *sorter) Less(i, j int) bool {
+	return s.less.Call([]reflect.Value{
+		s.sl.Index(i),
+		s.sl.Index(j),
+	})[0].Bool()
+}
+
+func (s *sorter) Swap(i, j int) {
+	t := reflect.New(s.sl.Type().Elem()).Elem()
+	t.Set(s.sl.Index(i))
+	s.sl.Index(i).Set(s.sl.Index(j))
+	s.sl.Index(j).Set(t)
+}
+
+func (s *sorter) Pop() interface{} {
+	ret := s.sl.Index(s.sl.Len() - 1).Interface()
+	s.sl.SetLen(s.sl.Len() - 1)
+	return ret
+}
+
+func (s *sorter) Push(val interface{}) {
+	s.sl = reflect.Append(s.sl, reflect.ValueOf(val))
+}