phares3757/gatus
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Fix dependencies

Browse Source
This commit is contained in:
TwinProduction
2020-12-25 03:00:08 -05:00
parent 10ab9265d9
commit 416178fb28
1449 changed files with 7770 additions and 474390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

92
vendor/github.com/modern-go/reflect2/safe_slice.go generated vendored
View File

@ -1,92 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type safeSliceType struct {
safeType
}
func (type2 *safeSliceType) SetIndex(obj interface{}, index int, value interface{}) {
val := reflect.ValueOf(obj).Elem()
elem := reflect.ValueOf(value).Elem()
val.Index(index).Set(elem)
}
func (type2 *safeSliceType) UnsafeSetIndex(obj unsafe.Pointer, index int, value unsafe.Pointer) {
panic("does not support unsafe operation")
}
func (type2 *safeSliceType) GetIndex(obj interface{}, index int) interface{} {
val := reflect.ValueOf(obj).Elem()
elem := val.Index(index)
ptr := reflect.New(elem.Type())
ptr.Elem().Set(elem)
return ptr.Interface()
}
func (type2 *safeSliceType) UnsafeGetIndex(obj unsafe.Pointer, index int) unsafe.Pointer {
panic("does not support unsafe operation")
}
func (type2 *safeSliceType) MakeSlice(length int, cap int) interface{} {
val := reflect.MakeSlice(type2.Type, length, cap)
ptr := reflect.New(val.Type())
ptr.Elem().Set(val)
return ptr.Interface()
}
func (type2 *safeSliceType) UnsafeMakeSlice(length int, cap int) unsafe.Pointer {
panic("does not support unsafe operation")
}
func (type2 *safeSliceType) Grow(obj interface{}, newLength int) {
oldCap := type2.Cap(obj)
oldSlice := reflect.ValueOf(obj).Elem()
delta := newLength - oldCap
deltaVals := make([]reflect.Value, delta)
newSlice := reflect.Append(oldSlice, deltaVals...)
oldSlice.Set(newSlice)
}
func (type2 *safeSliceType) UnsafeGrow(ptr unsafe.Pointer, newLength int) {
panic("does not support unsafe operation")
}
func (type2 *safeSliceType) Append(obj interface{}, elem interface{}) {
val := reflect.ValueOf(obj).Elem()
elemVal := reflect.ValueOf(elem).Elem()
newVal := reflect.Append(val, elemVal)
val.Set(newVal)
}
func (type2 *safeSliceType) UnsafeAppend(obj unsafe.Pointer, elem unsafe.Pointer) {
panic("does not support unsafe operation")
}
func (type2 *safeSliceType) SetNil(obj interface{}) {
val := reflect.ValueOf(obj).Elem()
val.Set(reflect.Zero(val.Type()))
}
func (type2 *safeSliceType) UnsafeSetNil(ptr unsafe.Pointer) {
panic("does not support unsafe operation")
}
func (type2 *safeSliceType) LengthOf(obj interface{}) int {
return reflect.ValueOf(obj).Elem().Len()
}
func (type2 *safeSliceType) UnsafeLengthOf(ptr unsafe.Pointer) int {
panic("does not support unsafe operation")
}
func (type2 *safeSliceType) Cap(obj interface{}) int {
return reflect.ValueOf(obj).Elem().Cap()
}
func (type2 *safeSliceType) UnsafeCap(ptr unsafe.Pointer) int {
panic("does not support unsafe operation")
}

29
vendor/github.com/modern-go/reflect2/safe_struct.go generated vendored
View File

@ -1,29 +0,0 @@
package reflect2
type safeStructType struct {
safeType
}
func (type2 *safeStructType) FieldByName(name string) StructField {
field, found := type2.Type.FieldByName(name)
if !found {
panic("field " + name + " not found")
}
return &safeField{StructField: field}
}
func (type2 *safeStructType) Field(i int) StructField {
return &safeField{StructField: type2.Type.Field(i)}
}
func (type2 *safeStructType) FieldByIndex(index []int) StructField {
return &safeField{StructField: type2.Type.FieldByIndex(index)}
}
func (type2 *safeStructType) FieldByNameFunc(match func(string) bool) StructField {
field, found := type2.Type.FieldByNameFunc(match)
if !found {
panic("field match condition not found in " + type2.Type.String())
}
return &safeField{StructField: field}
}

78
vendor/github.com/modern-go/reflect2/safe_type.go generated vendored
View File

@ -1,78 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type safeType struct {
reflect.Type
cfg *frozenConfig
}
func (type2 *safeType) New() interface{} {
return reflect.New(type2.Type).Interface()
}
func (type2 *safeType) UnsafeNew() unsafe.Pointer {
panic("does not support unsafe operation")
}
func (type2 *safeType) Elem() Type {
return type2.cfg.Type2(type2.Type.Elem())
}
func (type2 *safeType) Type1() reflect.Type {
return type2.Type
}
func (type2 *safeType) PackEFace(ptr unsafe.Pointer) interface{} {
panic("does not support unsafe operation")
}
func (type2 *safeType) Implements(thatType Type) bool {
return type2.Type.Implements(thatType.Type1())
}
func (type2 *safeType) RType() uintptr {
panic("does not support unsafe operation")
}
func (type2 *safeType) Indirect(obj interface{}) interface{} {
return reflect.Indirect(reflect.ValueOf(obj)).Interface()
}
func (type2 *safeType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
panic("does not support unsafe operation")
}
func (type2 *safeType) LikePtr() bool {
panic("does not support unsafe operation")
}
func (type2 *safeType) IsNullable() bool {
return IsNullable(type2.Kind())
}
func (type2 *safeType) IsNil(obj interface{}) bool {
if obj == nil {
return true
}
return reflect.ValueOf(obj).Elem().IsNil()
}
func (type2 *safeType) UnsafeIsNil(ptr unsafe.Pointer) bool {
panic("does not support unsafe operation")
}
func (type2 *safeType) Set(obj interface{}, val interface{}) {
reflect.ValueOf(obj).Elem().Set(reflect.ValueOf(val).Elem())
}
func (type2 *safeType) UnsafeSet(ptr unsafe.Pointer, val unsafe.Pointer) {
panic("does not support unsafe operation")
}
func (type2 *safeType) AssignableTo(anotherType Type) bool {
return type2.Type1().AssignableTo(anotherType.Type1())
}

12
vendor/github.com/modern-go/reflect2/test.sh generated vendored
View File

@ -1,12 +0,0 @@
#!/usr/bin/env bash
set -e
echo "" > coverage.txt
for d in $(go list github.com/modern-go/reflect2-tests/... | grep -v vendor); do
go test -coverprofile=profile.out -coverpkg=github.com/modern-go/reflect2 $d
if [ -f profile.out ]; then
cat profile.out >> coverage.txt
rm profile.out
fi
done

113
vendor/github.com/modern-go/reflect2/type_map.go generated vendored
View File

@ -1,113 +0,0 @@
package reflect2
import (
"reflect"
"runtime"
"strings"
"sync"
"unsafe"
)
// typelinks1 for 1.5 ~ 1.6
//go:linkname typelinks1 reflect.typelinks
func typelinks1() [][]unsafe.Pointer
// typelinks2 for 1.7 ~
//go:linkname typelinks2 reflect.typelinks
func typelinks2() (sections []unsafe.Pointer, offset [][]int32)
// initOnce guards initialization of types and packages
var initOnce sync.Once
var types map[string]reflect.Type
var packages map[string]map[string]reflect.Type
// discoverTypes initializes types and packages
func discoverTypes() {
types = make(map[string]reflect.Type)
packages = make(map[string]map[string]reflect.Type)
ver := runtime.Version()
if ver == "go1.5" || strings.HasPrefix(ver, "go1.5.") {
loadGo15Types()
} else if ver == "go1.6" || strings.HasPrefix(ver, "go1.6.") {
loadGo15Types()
} else {
loadGo17Types()
}
}
func loadGo15Types() {
var obj interface{} = reflect.TypeOf(0)
typePtrss := typelinks1()
for _, typePtrs := range typePtrss {
for _, typePtr := range typePtrs {
(*emptyInterface)(unsafe.Pointer(&obj)).word = typePtr
typ := obj.(reflect.Type)
if typ.Kind() == reflect.Ptr && typ.Elem().Kind() == reflect.Struct {
loadedType := typ.Elem()
pkgTypes := packages[loadedType.PkgPath()]
if pkgTypes == nil {
pkgTypes = map[string]reflect.Type{}
packages[loadedType.PkgPath()] = pkgTypes
}
types[loadedType.String()] = loadedType
pkgTypes[loadedType.Name()] = loadedType
}
if typ.Kind() == reflect.Slice && typ.Elem().Kind() == reflect.Ptr &&
typ.Elem().Elem().Kind() == reflect.Struct {
loadedType := typ.Elem().Elem()
pkgTypes := packages[loadedType.PkgPath()]
if pkgTypes == nil {
pkgTypes = map[string]reflect.Type{}
packages[loadedType.PkgPath()] = pkgTypes
}
types[loadedType.String()] = loadedType
pkgTypes[loadedType.Name()] = loadedType
}
}
}
}
func loadGo17Types() {
var obj interface{} = reflect.TypeOf(0)
sections, offset := typelinks2()
for i, offs := range offset {
rodata := sections[i]
for _, off := range offs {
(*emptyInterface)(unsafe.Pointer(&obj)).word = resolveTypeOff(unsafe.Pointer(rodata), off)
typ := obj.(reflect.Type)
if typ.Kind() == reflect.Ptr && typ.Elem().Kind() == reflect.Struct {
loadedType := typ.Elem()
pkgTypes := packages[loadedType.PkgPath()]
if pkgTypes == nil {
pkgTypes = map[string]reflect.Type{}
packages[loadedType.PkgPath()] = pkgTypes
}
types[loadedType.String()] = loadedType
pkgTypes[loadedType.Name()] = loadedType
}
}
}
}
type emptyInterface struct {
typ unsafe.Pointer
word unsafe.Pointer
}
// TypeByName return the type by its name, just like Class.forName in java
func TypeByName(typeName string) Type {
initOnce.Do(discoverTypes)
return Type2(types[typeName])
}
// TypeByPackageName return the type by its package and name
func TypeByPackageName(pkgPath string, name string) Type {
initOnce.Do(discoverTypes)
pkgTypes := packages[pkgPath]
if pkgTypes == nil {
return nil
}
return Type2(pkgTypes[name])
}

65
vendor/github.com/modern-go/reflect2/unsafe_array.go generated vendored
View File

@ -1,65 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type UnsafeArrayType struct {
unsafeType
elemRType unsafe.Pointer
pElemRType unsafe.Pointer
elemSize uintptr
likePtr bool
}
func newUnsafeArrayType(cfg *frozenConfig, type1 reflect.Type) *UnsafeArrayType {
return &UnsafeArrayType{
unsafeType: *newUnsafeType(cfg, type1),
elemRType: unpackEFace(type1.Elem()).data,
pElemRType: unpackEFace(reflect.PtrTo(type1.Elem())).data,
elemSize: type1.Elem().Size(),
likePtr: likePtrType(type1),
}
}
func (type2 *UnsafeArrayType) LikePtr() bool {
return type2.likePtr
}
func (type2 *UnsafeArrayType) Indirect(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIndirect(objEFace.data)
}
func (type2 *UnsafeArrayType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
if type2.likePtr {
return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
}
return packEFace(type2.rtype, ptr)
}
func (type2 *UnsafeArrayType) SetIndex(obj interface{}, index int, elem interface{}) {
objEFace := unpackEFace(obj)
assertType("ArrayType.SetIndex argument 1", type2.ptrRType, objEFace.rtype)
elemEFace := unpackEFace(elem)
assertType("ArrayType.SetIndex argument 3", type2.pElemRType, elemEFace.rtype)
type2.UnsafeSetIndex(objEFace.data, index, elemEFace.data)
}
func (type2 *UnsafeArrayType) UnsafeSetIndex(obj unsafe.Pointer, index int, elem unsafe.Pointer) {
elemPtr := arrayAt(obj, index, type2.elemSize, "i < s.Len")
typedmemmove(type2.elemRType, elemPtr, elem)
}
func (type2 *UnsafeArrayType) GetIndex(obj interface{}, index int) interface{} {
objEFace := unpackEFace(obj)
assertType("ArrayType.GetIndex argument 1", type2.ptrRType, objEFace.rtype)
elemPtr := type2.UnsafeGetIndex(objEFace.data, index)
return packEFace(type2.pElemRType, elemPtr)
}
func (type2 *UnsafeArrayType) UnsafeGetIndex(obj unsafe.Pointer, index int) unsafe.Pointer {
return arrayAt(obj, index, type2.elemSize, "i < s.Len")
}

59
vendor/github.com/modern-go/reflect2/unsafe_eface.go generated vendored
View File

@ -1,59 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type eface struct {
rtype unsafe.Pointer
data unsafe.Pointer
}
func unpackEFace(obj interface{}) *eface {
return (*eface)(unsafe.Pointer(&obj))
}
func packEFace(rtype unsafe.Pointer, data unsafe.Pointer) interface{} {
var i interface{}
e := (*eface)(unsafe.Pointer(&i))
e.rtype = rtype
e.data = data
return i
}
type UnsafeEFaceType struct {
unsafeType
}
func newUnsafeEFaceType(cfg *frozenConfig, type1 reflect.Type) *UnsafeEFaceType {
return &UnsafeEFaceType{
unsafeType: *newUnsafeType(cfg, type1),
}
}
func (type2 *UnsafeEFaceType) IsNil(obj interface{}) bool {
if obj == nil {
return true
}
objEFace := unpackEFace(obj)
assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIsNil(objEFace.data)
}
func (type2 *UnsafeEFaceType) UnsafeIsNil(ptr unsafe.Pointer) bool {
if ptr == nil {
return true
}
return unpackEFace(*(*interface{})(ptr)).data == nil
}
func (type2 *UnsafeEFaceType) Indirect(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIndirect(objEFace.data)
}
func (type2 *UnsafeEFaceType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
return *(*interface{})(ptr)
}

74
vendor/github.com/modern-go/reflect2/unsafe_field.go generated vendored
View File

@ -1,74 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type UnsafeStructField struct {
reflect.StructField
structType *UnsafeStructType
rtype unsafe.Pointer
ptrRType unsafe.Pointer
}
func newUnsafeStructField(structType *UnsafeStructType, structField reflect.StructField) *UnsafeStructField {
return &UnsafeStructField{
StructField: structField,
rtype: unpackEFace(structField.Type).data,
ptrRType: unpackEFace(reflect.PtrTo(structField.Type)).data,
structType: structType,
}
}
func (field *UnsafeStructField) Offset() uintptr {
return field.StructField.Offset
}
func (field *UnsafeStructField) Name() string {
return field.StructField.Name
}
func (field *UnsafeStructField) PkgPath() string {
return field.StructField.PkgPath
}
func (field *UnsafeStructField) Type() Type {
return field.structType.cfg.Type2(field.StructField.Type)
}
func (field *UnsafeStructField) Tag() reflect.StructTag {
return field.StructField.Tag
}
func (field *UnsafeStructField) Index() []int {
return field.StructField.Index
}
func (field *UnsafeStructField) Anonymous() bool {
return field.StructField.Anonymous
}
func (field *UnsafeStructField) Set(obj interface{}, value interface{}) {
objEFace := unpackEFace(obj)
assertType("StructField.SetIndex argument 1", field.structType.ptrRType, objEFace.rtype)
valueEFace := unpackEFace(value)
assertType("StructField.SetIndex argument 2", field.ptrRType, valueEFace.rtype)
field.UnsafeSet(objEFace.data, valueEFace.data)
}
func (field *UnsafeStructField) UnsafeSet(obj unsafe.Pointer, value unsafe.Pointer) {
fieldPtr := add(obj, field.StructField.Offset, "same as non-reflect &v.field")
typedmemmove(field.rtype, fieldPtr, value)
}
func (field *UnsafeStructField) Get(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("StructField.GetIndex argument 1", field.structType.ptrRType, objEFace.rtype)
value := field.UnsafeGet(objEFace.data)
return packEFace(field.ptrRType, value)
}
func (field *UnsafeStructField) UnsafeGet(obj unsafe.Pointer) unsafe.Pointer {
return add(obj, field.StructField.Offset, "same as non-reflect &v.field")
}

64
vendor/github.com/modern-go/reflect2/unsafe_iface.go generated vendored
View File

@ -1,64 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type iface struct {
itab *itab
data unsafe.Pointer
}
type itab struct {
ignore unsafe.Pointer
rtype unsafe.Pointer
}
func IFaceToEFace(ptr unsafe.Pointer) interface{} {
iface := (*iface)(ptr)
if iface.itab == nil {
return nil
}
return packEFace(iface.itab.rtype, iface.data)
}
type UnsafeIFaceType struct {
unsafeType
}
func newUnsafeIFaceType(cfg *frozenConfig, type1 reflect.Type) *UnsafeIFaceType {
return &UnsafeIFaceType{
unsafeType: *newUnsafeType(cfg, type1),
}
}
func (type2 *UnsafeIFaceType) Indirect(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIndirect(objEFace.data)
}
func (type2 *UnsafeIFaceType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
return IFaceToEFace(ptr)
}
func (type2 *UnsafeIFaceType) IsNil(obj interface{}) bool {
if obj == nil {
return true
}
objEFace := unpackEFace(obj)
assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIsNil(objEFace.data)
}
func (type2 *UnsafeIFaceType) UnsafeIsNil(ptr unsafe.Pointer) bool {
if ptr == nil {
return true
}
iface := (*iface)(ptr)
if iface.itab == nil {
return true
}
return false
}

70
vendor/github.com/modern-go/reflect2/unsafe_link.go generated vendored
View File

@ -1,70 +0,0 @@
package reflect2
import "unsafe"
//go:linkname unsafe_New reflect.unsafe_New
func unsafe_New(rtype unsafe.Pointer) unsafe.Pointer
//go:linkname typedmemmove reflect.typedmemmove
func typedmemmove(rtype unsafe.Pointer, dst, src unsafe.Pointer)
//go:linkname unsafe_NewArray reflect.unsafe_NewArray
func unsafe_NewArray(rtype unsafe.Pointer, length int) unsafe.Pointer
// typedslicecopy copies a slice of elemType values from src to dst,
// returning the number of elements copied.
//go:linkname typedslicecopy reflect.typedslicecopy
//go:noescape
func typedslicecopy(elemType unsafe.Pointer, dst, src sliceHeader) int
//go:linkname mapassign reflect.mapassign
//go:noescape
func mapassign(rtype unsafe.Pointer, m unsafe.Pointer, key, val unsafe.Pointer)
//go:linkname mapaccess reflect.mapaccess
//go:noescape
func mapaccess(rtype unsafe.Pointer, m unsafe.Pointer, key unsafe.Pointer) (val unsafe.Pointer)
// m escapes into the return value, but the caller of mapiterinit
// doesn't let the return value escape.
//go:noescape
//go:linkname mapiterinit reflect.mapiterinit
func mapiterinit(rtype unsafe.Pointer, m unsafe.Pointer) *hiter
//go:noescape
//go:linkname mapiternext reflect.mapiternext
func mapiternext(it *hiter)
//go:linkname ifaceE2I reflect.ifaceE2I
func ifaceE2I(rtype unsafe.Pointer, src interface{}, dst unsafe.Pointer)
// A hash iteration structure.
// If you modify hiter, also change cmd/internal/gc/reflect.go to indicate
// the layout of this structure.
type hiter struct {
key unsafe.Pointer // Must be in first position. Write nil to indicate iteration end (see cmd/internal/gc/range.go).
value unsafe.Pointer // Must be in second position (see cmd/internal/gc/range.go).
// rest fields are ignored
}
// add returns p+x.
//
// The whySafe string is ignored, so that the function still inlines
// as efficiently as p+x, but all call sites should use the string to
// record why the addition is safe, which is to say why the addition
// does not cause x to advance to the very end of p's allocation
// and therefore point incorrectly at the next block in memory.
func add(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
return unsafe.Pointer(uintptr(p) + x)
}
// arrayAt returns the i-th element of p,
// an array whose elements are eltSize bytes wide.
// The array pointed at by p must have at least i+1 elements:
// it is invalid (but impossible to check here) to pass i >= len,
// because then the result will point outside the array.
// whySafe must explain why i < len. (Passing "i < len" is fine;
// the benefit is to surface this assumption at the call site.)
func arrayAt(p unsafe.Pointer, i int, eltSize uintptr, whySafe string) unsafe.Pointer {
return add(p, uintptr(i)*eltSize, "i < len")
}

138
vendor/github.com/modern-go/reflect2/unsafe_map.go generated vendored
View File

@ -1,138 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type UnsafeMapType struct {
unsafeType
pKeyRType unsafe.Pointer
pElemRType unsafe.Pointer
}
func newUnsafeMapType(cfg *frozenConfig, type1 reflect.Type) MapType {
return &UnsafeMapType{
unsafeType: *newUnsafeType(cfg, type1),
pKeyRType: unpackEFace(reflect.PtrTo(type1.Key())).data,
pElemRType: unpackEFace(reflect.PtrTo(type1.Elem())).data,
}
}
func (type2 *UnsafeMapType) IsNil(obj interface{}) bool {
if obj == nil {
return true
}
objEFace := unpackEFace(obj)
assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIsNil(objEFace.data)
}
func (type2 *UnsafeMapType) UnsafeIsNil(ptr unsafe.Pointer) bool {
if ptr == nil {
return true
}
return *(*unsafe.Pointer)(ptr) == nil
}
func (type2 *UnsafeMapType) LikePtr() bool {
return true
}
func (type2 *UnsafeMapType) Indirect(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("MapType.Indirect argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIndirect(objEFace.data)
}
func (type2 *UnsafeMapType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
}
func (type2 *UnsafeMapType) Key() Type {
return type2.cfg.Type2(type2.Type.Key())
}
func (type2 *UnsafeMapType) MakeMap(cap int) interface{} {
return packEFace(type2.ptrRType, type2.UnsafeMakeMap(cap))
}
func (type2 *UnsafeMapType) UnsafeMakeMap(cap int) unsafe.Pointer {
m := makeMapWithSize(type2.rtype, cap)
return unsafe.Pointer(&m)
}
func (type2 *UnsafeMapType) SetIndex(obj interface{}, key interface{}, elem interface{}) {
objEFace := unpackEFace(obj)
assertType("MapType.SetIndex argument 1", type2.ptrRType, objEFace.rtype)
keyEFace := unpackEFace(key)
assertType("MapType.SetIndex argument 2", type2.pKeyRType, keyEFace.rtype)
elemEFace := unpackEFace(elem)
assertType("MapType.SetIndex argument 3", type2.pElemRType, elemEFace.rtype)
type2.UnsafeSetIndex(objEFace.data, keyEFace.data, elemEFace.data)
}
func (type2 *UnsafeMapType) UnsafeSetIndex(obj unsafe.Pointer, key unsafe.Pointer, elem unsafe.Pointer) {
mapassign(type2.rtype, *(*unsafe.Pointer)(obj), key, elem)
}
func (type2 *UnsafeMapType) TryGetIndex(obj interface{}, key interface{}) (interface{}, bool) {
objEFace := unpackEFace(obj)
assertType("MapType.TryGetIndex argument 1", type2.ptrRType, objEFace.rtype)
keyEFace := unpackEFace(key)
assertType("MapType.TryGetIndex argument 2", type2.pKeyRType, keyEFace.rtype)
elemPtr := type2.UnsafeGetIndex(objEFace.data, keyEFace.data)
if elemPtr == nil {
return nil, false
}
return packEFace(type2.pElemRType, elemPtr), true
}
func (type2 *UnsafeMapType) GetIndex(obj interface{}, key interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("MapType.GetIndex argument 1", type2.ptrRType, objEFace.rtype)
keyEFace := unpackEFace(key)
assertType("MapType.GetIndex argument 2", type2.pKeyRType, keyEFace.rtype)
elemPtr := type2.UnsafeGetIndex(objEFace.data, keyEFace.data)
return packEFace(type2.pElemRType, elemPtr)
}
func (type2 *UnsafeMapType) UnsafeGetIndex(obj unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
return mapaccess(type2.rtype, *(*unsafe.Pointer)(obj), key)
}
func (type2 *UnsafeMapType) Iterate(obj interface{}) MapIterator {
objEFace := unpackEFace(obj)
assertType("MapType.Iterate argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIterate(objEFace.data)
}
func (type2 *UnsafeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator {
return &UnsafeMapIterator{
hiter: mapiterinit(type2.rtype, *(*unsafe.Pointer)(obj)),
pKeyRType: type2.pKeyRType,
pElemRType: type2.pElemRType,
}
}
type UnsafeMapIterator struct {
*hiter
pKeyRType unsafe.Pointer
pElemRType unsafe.Pointer
}
func (iter *UnsafeMapIterator) HasNext() bool {
return iter.key != nil
}
func (iter *UnsafeMapIterator) Next() (interface{}, interface{}) {
key, elem := iter.UnsafeNext()
return packEFace(iter.pKeyRType, key), packEFace(iter.pElemRType, elem)
}
func (iter *UnsafeMapIterator) UnsafeNext() (unsafe.Pointer, unsafe.Pointer) {
key := iter.key
elem := iter.value
mapiternext(iter.hiter)
return key, elem
}

46
vendor/github.com/modern-go/reflect2/unsafe_ptr.go generated vendored
View File

@ -1,46 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type UnsafePtrType struct {
unsafeType
}
func newUnsafePtrType(cfg *frozenConfig, type1 reflect.Type) *UnsafePtrType {
return &UnsafePtrType{
unsafeType: *newUnsafeType(cfg, type1),
}
}
func (type2 *UnsafePtrType) IsNil(obj interface{}) bool {
if obj == nil {
return true
}
objEFace := unpackEFace(obj)
assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIsNil(objEFace.data)
}
func (type2 *UnsafePtrType) UnsafeIsNil(ptr unsafe.Pointer) bool {
if ptr == nil {
return true
}
return *(*unsafe.Pointer)(ptr) == nil
}
func (type2 *UnsafePtrType) LikePtr() bool {
return true
}
func (type2 *UnsafePtrType) Indirect(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIndirect(objEFace.data)
}
func (type2 *UnsafePtrType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
}

177
vendor/github.com/modern-go/reflect2/unsafe_slice.go generated vendored
View File

@ -1,177 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
// sliceHeader is a safe version of SliceHeader used within this package.
type sliceHeader struct {
Data unsafe.Pointer
Len int
Cap int
}
type UnsafeSliceType struct {
unsafeType
elemRType unsafe.Pointer
pElemRType unsafe.Pointer
elemSize uintptr
}
func newUnsafeSliceType(cfg *frozenConfig, type1 reflect.Type) SliceType {
elemType := type1.Elem()
return &UnsafeSliceType{
unsafeType: *newUnsafeType(cfg, type1),
pElemRType: unpackEFace(reflect.PtrTo(elemType)).data,
elemRType: unpackEFace(elemType).data,
elemSize: elemType.Size(),
}
}
func (type2 *UnsafeSliceType) Set(obj interface{}, val interface{}) {
objEFace := unpackEFace(obj)
assertType("Type.Set argument 1", type2.ptrRType, objEFace.rtype)
valEFace := unpackEFace(val)
assertType("Type.Set argument 2", type2.ptrRType, valEFace.rtype)
type2.UnsafeSet(objEFace.data, valEFace.data)
}
func (type2 *UnsafeSliceType) UnsafeSet(ptr unsafe.Pointer, val unsafe.Pointer) {
*(*sliceHeader)(ptr) = *(*sliceHeader)(val)
}
func (type2 *UnsafeSliceType) IsNil(obj interface{}) bool {
if obj == nil {
return true
}
objEFace := unpackEFace(obj)
assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIsNil(objEFace.data)
}
func (type2 *UnsafeSliceType) UnsafeIsNil(ptr unsafe.Pointer) bool {
if ptr == nil {
return true
}
return (*sliceHeader)(ptr).Data == nil
}
func (type2 *UnsafeSliceType) SetNil(obj interface{}) {
objEFace := unpackEFace(obj)
assertType("SliceType.SetNil argument 1", type2.ptrRType, objEFace.rtype)
type2.UnsafeSetNil(objEFace.data)
}
func (type2 *UnsafeSliceType) UnsafeSetNil(ptr unsafe.Pointer) {
header := (*sliceHeader)(ptr)
header.Len = 0
header.Cap = 0
header.Data = nil
}
func (type2 *UnsafeSliceType) MakeSlice(length int, cap int) interface{} {
return packEFace(type2.ptrRType, type2.UnsafeMakeSlice(length, cap))
}
func (type2 *UnsafeSliceType) UnsafeMakeSlice(length int, cap int) unsafe.Pointer {
header := &sliceHeader{unsafe_NewArray(type2.elemRType, cap), length, cap}
return unsafe.Pointer(header)
}
func (type2 *UnsafeSliceType) LengthOf(obj interface{}) int {
objEFace := unpackEFace(obj)
assertType("SliceType.Len argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeLengthOf(objEFace.data)
}
func (type2 *UnsafeSliceType) UnsafeLengthOf(obj unsafe.Pointer) int {
header := (*sliceHeader)(obj)
return header.Len
}
func (type2 *UnsafeSliceType) SetIndex(obj interface{}, index int, elem interface{}) {
objEFace := unpackEFace(obj)
assertType("SliceType.SetIndex argument 1", type2.ptrRType, objEFace.rtype)
elemEFace := unpackEFace(elem)
assertType("SliceType.SetIndex argument 3", type2.pElemRType, elemEFace.rtype)
type2.UnsafeSetIndex(objEFace.data, index, elemEFace.data)
}
func (type2 *UnsafeSliceType) UnsafeSetIndex(obj unsafe.Pointer, index int, elem unsafe.Pointer) {
header := (*sliceHeader)(obj)
elemPtr := arrayAt(header.Data, index, type2.elemSize, "i < s.Len")
typedmemmove(type2.elemRType, elemPtr, elem)
}
func (type2 *UnsafeSliceType) GetIndex(obj interface{}, index int) interface{} {
objEFace := unpackEFace(obj)
assertType("SliceType.GetIndex argument 1", type2.ptrRType, objEFace.rtype)
elemPtr := type2.UnsafeGetIndex(objEFace.data, index)
return packEFace(type2.pElemRType, elemPtr)
}
func (type2 *UnsafeSliceType) UnsafeGetIndex(obj unsafe.Pointer, index int) unsafe.Pointer {
header := (*sliceHeader)(obj)
return arrayAt(header.Data, index, type2.elemSize, "i < s.Len")
}
func (type2 *UnsafeSliceType) Append(obj interface{}, elem interface{}) {
objEFace := unpackEFace(obj)
assertType("SliceType.Append argument 1", type2.ptrRType, objEFace.rtype)
elemEFace := unpackEFace(elem)
assertType("SliceType.Append argument 2", type2.pElemRType, elemEFace.rtype)
type2.UnsafeAppend(objEFace.data, elemEFace.data)
}
func (type2 *UnsafeSliceType) UnsafeAppend(obj unsafe.Pointer, elem unsafe.Pointer) {
header := (*sliceHeader)(obj)
oldLen := header.Len
type2.UnsafeGrow(obj, oldLen+1)
type2.UnsafeSetIndex(obj, oldLen, elem)
}
func (type2 *UnsafeSliceType) Cap(obj interface{}) int {
objEFace := unpackEFace(obj)
assertType("SliceType.Cap argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeCap(objEFace.data)
}
func (type2 *UnsafeSliceType) UnsafeCap(ptr unsafe.Pointer) int {
return (*sliceHeader)(ptr).Cap
}
func (type2 *UnsafeSliceType) Grow(obj interface{}, newLength int) {
objEFace := unpackEFace(obj)
assertType("SliceType.Grow argument 1", type2.ptrRType, objEFace.rtype)
type2.UnsafeGrow(objEFace.data, newLength)
}
func (type2 *UnsafeSliceType) UnsafeGrow(obj unsafe.Pointer, newLength int) {
header := (*sliceHeader)(obj)
if newLength <= header.Cap {
header.Len = newLength
return
}
newCap := calcNewCap(header.Cap, newLength)
newHeader := (*sliceHeader)(type2.UnsafeMakeSlice(header.Len, newCap))
typedslicecopy(type2.elemRType, *newHeader, *header)
header.Data = newHeader.Data
header.Cap = newHeader.Cap
header.Len = newLength
}
func calcNewCap(cap int, expectedCap int) int {
if cap == 0 {
cap = expectedCap
} else {
for cap < expectedCap {
if cap < 1024 {
cap += cap
} else {
cap += cap / 4
}
}
}
return cap
}

59
vendor/github.com/modern-go/reflect2/unsafe_struct.go generated vendored
View File

@ -1,59 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type UnsafeStructType struct {
unsafeType
likePtr bool
}
func newUnsafeStructType(cfg *frozenConfig, type1 reflect.Type) *UnsafeStructType {
return &UnsafeStructType{
unsafeType: *newUnsafeType(cfg, type1),
likePtr: likePtrType(type1),
}
}
func (type2 *UnsafeStructType) LikePtr() bool {
return type2.likePtr
}
func (type2 *UnsafeStructType) Indirect(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIndirect(objEFace.data)
}
func (type2 *UnsafeStructType) UnsafeIndirect(ptr unsafe.Pointer) interface{} {
if type2.likePtr {
return packEFace(type2.rtype, *(*unsafe.Pointer)(ptr))
}
return packEFace(type2.rtype, ptr)
}
func (type2 *UnsafeStructType) FieldByName(name string) StructField {
structField, found := type2.Type.FieldByName(name)
if !found {
return nil
}
return newUnsafeStructField(type2, structField)
}
func (type2 *UnsafeStructType) Field(i int) StructField {
return newUnsafeStructField(type2, type2.Type.Field(i))
}
func (type2 *UnsafeStructType) FieldByIndex(index []int) StructField {
return newUnsafeStructField(type2, type2.Type.FieldByIndex(index))
}
func (type2 *UnsafeStructType) FieldByNameFunc(match func(string) bool) StructField {
structField, found := type2.Type.FieldByNameFunc(match)
if !found {
panic("field match condition not found in " + type2.Type.String())
}
return newUnsafeStructField(type2, structField)
}

85
vendor/github.com/modern-go/reflect2/unsafe_type.go generated vendored
View File

@ -1,85 +0,0 @@
package reflect2
import (
"reflect"
"unsafe"
)
type unsafeType struct {
safeType
rtype unsafe.Pointer
ptrRType unsafe.Pointer
}
func newUnsafeType(cfg *frozenConfig, type1 reflect.Type) *unsafeType {
return &unsafeType{
safeType: safeType{
Type: type1,
cfg: cfg,
},
rtype: unpackEFace(type1).data,
ptrRType: unpackEFace(reflect.PtrTo(type1)).data,
}
}
func (type2 *unsafeType) Set(obj interface{}, val interface{}) {
objEFace := unpackEFace(obj)
assertType("Type.Set argument 1", type2.ptrRType, objEFace.rtype)
valEFace := unpackEFace(val)
assertType("Type.Set argument 2", type2.ptrRType, valEFace.rtype)
type2.UnsafeSet(objEFace.data, valEFace.data)
}
func (type2 *unsafeType) UnsafeSet(ptr unsafe.Pointer, val unsafe.Pointer) {
typedmemmove(type2.rtype, ptr, val)
}
func (type2 *unsafeType) IsNil(obj interface{}) bool {
objEFace := unpackEFace(obj)
assertType("Type.IsNil argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIsNil(objEFace.data)
}
func (type2 *unsafeType) UnsafeIsNil(ptr unsafe.Pointer) bool {
return ptr == nil
}
func (type2 *unsafeType) UnsafeNew() unsafe.Pointer {
return unsafe_New(type2.rtype)
}
func (type2 *unsafeType) New() interface{} {
return packEFace(type2.ptrRType, type2.UnsafeNew())
}
func (type2 *unsafeType) PackEFace(ptr unsafe.Pointer) interface{} {
return packEFace(type2.ptrRType, ptr)
}
func (type2 *unsafeType) RType() uintptr {
return uintptr(type2.rtype)
}
func (type2 *unsafeType) Indirect(obj interface{}) interface{} {
objEFace := unpackEFace(obj)
assertType("Type.Indirect argument 1", type2.ptrRType, objEFace.rtype)
return type2.UnsafeIndirect(objEFace.data)
}
func (type2 *unsafeType) UnsafeIndirect(obj unsafe.Pointer) interface{} {
return packEFace(type2.rtype, obj)
}
func (type2 *unsafeType) LikePtr() bool {
return false
}
func assertType(where string, expectRType unsafe.Pointer, actualRType unsafe.Pointer) {
if expectRType != actualRType {
expectType := reflect.TypeOf(0)
(*iface)(unsafe.Pointer(&expectType)).data = expectRType
actualType := reflect.TypeOf(0)
(*iface)(unsafe.Pointer(&actualType)).data = actualRType
panic(where + ": expect " + expectType.String() + ", actual " + actualType.String())
}
}