type reflect.Value

385 uses

	reflect (current package)
		badlinkname.go#L130: func badlinkname_Value_pointer(Value) unsafe.Pointer
		deepequal.go#L27: func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool {
		deepequal.go#L39: 	hard := func(v1, v2 Value) bool {
		deepequal.go#L63: 		ptrval := func(v Value) unsafe.Pointer {
		iter.go#L13: 	uintptr, N int64 | uint64](num N, t Type) iter.Seq[Value] {
		iter.go#L14: 	return func(yield func(v Value) bool) {
		iter.go#L38: func (v Value) Seq() iter.Seq[Value] {
		iter.go#L40: 		return func(yield func(Value) bool) {
		iter.go#L41: 			rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
		iter.go#L42: 				return []Value{ValueOf(yield(in[0]))}
		iter.go#L44: 			v.Call([]Value{rf})
		iter.go#L74: 		return func(yield func(Value) bool) {
		iter.go#L83: 		return func(yield func(Value) bool) {
		iter.go#L91: 		return func(yield func(Value) bool) {
		iter.go#L99: 		return func(yield func(Value) bool) {
		iter.go#L108: 		return func(yield func(Value) bool) {
		iter.go#L124: func (v Value) Seq2() iter.Seq2[Value, Value] {
		iter.go#L126: 		return func(yield func(Value, Value) bool) {
		iter.go#L127: 			rf := MakeFunc(v.Type().In(0), func(in []Value) []Value {
		iter.go#L128: 				return []Value{ValueOf(yield(in[0], in[1]))}
		iter.go#L130: 			v.Call([]Value{rf})
		iter.go#L138: 		return func(yield func(Value, Value) bool) {
		iter.go#L147: 		return func(yield func(Value, Value) bool) {
		iter.go#L155: 		return func(yield func(Value, Value) bool) {
		iter.go#L163: 		return func(yield func(Value, Value) bool) {
		makefunc.go#L22: 	fn   func([]Value) []Value
		makefunc.go#L46: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
		makefunc.go#L70: 	return Value{t, unsafe.Pointer(impl), flag(Func)}
		makefunc.go#L86: 	rcvr   Value
		makefunc.go#L96: func makeMethodValue(op string, v Value) Value {
		makefunc.go#L104: 	rcvr := Value{v.typ(), v.ptr, fl}
		makefunc.go#L129: 	return Value{ftyp.Common(), unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
		type.go#L454: 	Func  Value // func with receiver as first argument
		type.go#L644: 	m.Func = Value{&mt.(*rtype).t, fn, fl}
		value.go#L39: type Value struct {
		value.go#L99: func (v Value) typ() *abi.Type {
		value.go#L111: func (v Value) pointer() unsafe.Pointer {
		value.go#L122: func packEface(v Value) any {
		value.go#L157: func unpackEface(i any) Value {
		value.go#L162: 		return Value{}
		value.go#L168: 	return Value{t, e.Data, f}
		value.go#L269: func (v Value) Addr() Value {
		value.go#L276: 	return Value{ptrTo(v.typ()), v.ptr, fl | flag(Pointer)}
		value.go#L281: func (v Value) Bool() bool {
		value.go#L289: func (v Value) panicNotBool() {
		value.go#L298: func (v Value) Bytes() []byte {
		value.go#L306: func (v Value) bytesSlow() []byte {
		value.go#L330: func (v Value) runes() []rune {
		value.go#L344: func (v Value) CanAddr() bool {
		value.go#L353: func (v Value) CanSet() bool {
		value.go#L365: func (v Value) Call(in []Value) []Value {
		value.go#L378: func (v Value) CallSlice(in []Value) []Value {
		value.go#L388: func (v Value) call(op string, in []Value) []Value {
		value.go#L393: 		rcvr     Value
		value.go#L456: 		in = make([]Value, n+1)
		value.go#L591: 	var ret []Value
		value.go#L606: 		ret = make([]Value, nout)
		value.go#L621: 				ret[i] = Value{tv, add(stackArgs, st.stkOff, "tv.Size() != 0"), fl}
		value.go#L637: 				ret[i] = Value{tv, regArgs.Ptrs[steps[0].ireg], flag(tv.Kind())}
		value.go#L668: 			ret[i] = Value{tv, s, flagIndir | flag(tv.Kind())}
		value.go#L711: 	in := make([]Value, 0, int(ftyp.InCount))
		value.go#L717: 		v := Value{typ, nil, flag(typ.Kind())}
		value.go#L875: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *abi.Type, t *funcType, fn unsafe.Pointer) {
		value.go#L914: func storeRcvr(v Value, p unsafe.Pointer) {
		value.go#L1142: func funcName(f func([]Value) []Value) string {
		value.go#L1153: func (v Value) Cap() int {
		value.go#L1161: func (v Value) capNonSlice() int {
		value.go#L1180: func (v Value) Close() {
		value.go#L1192: func (v Value) CanComplex() bool {
		value.go#L1203: func (v Value) Complex() complex128 {
		value.go#L1218: func (v Value) Elem() Value {
		value.go#L1257: 			return Value{}
		value.go#L1263: 		return Value{typ, ptr, fl}
		value.go#L1270: func (v Value) Field(i int) Value {
		value.go#L1297: 	return Value{typ, ptr, fl}
		value.go#L1303: func (v Value) FieldByIndex(index []int) Value {
		value.go#L1326: func (v Value) FieldByIndexErr(index []int) (Value, error) {
		value.go#L1335: 					return Value{}, errors.New("reflect: indirection through nil pointer to embedded struct field " + nameFor(v.typ().Elem()))
		value.go#L1348: func (v Value) FieldByName(name string) Value {
		value.go#L1353: 	return Value{}
		value.go#L1360: func (v Value) FieldByNameFunc(match func(string) bool) Value {
		value.go#L1364: 	return Value{}
		value.go#L1368: func (v Value) CanFloat() bool {
		value.go#L1379: func (v Value) Float() float64 {
		value.go#L1394: func (v Value) Index(i int) Value {
		value.go#L1411: 		return Value{typ, val, fl}
		value.go#L1424: 		return Value{typ, val, fl}
		value.go#L1433: 		return Value{uint8Type, p, fl}
		value.go#L1439: func (v Value) CanInt() bool {
		value.go#L1450: func (v Value) Int() int64 {
		value.go#L1469: func (v Value) CanInterface() bool {
		value.go#L1483: func (v Value) Interface() (i any) {
		value.go#L1487: func valueInterface(v Value, safe bool) any {
		value.go#L1525: func (v Value) InterfaceData() [2]uintptr {
		value.go#L1544: func (v Value) IsNil() bool {
		value.go#L1569: func (v Value) IsValid() bool {
		value.go#L1575: func (v Value) IsZero() bool {
		value.go#L1696: func (v Value) SetZero() {
		value.go#L1750: func (v Value) Kind() Kind {
		value.go#L1756: func (v Value) Len() int {
		value.go#L1764: func (v Value) lenNonSlice() int {
		value.go#L1791: func (v Value) MapIndex(key Value) Value {
		value.go#L1818: 		return Value{}
		value.go#L1830: func (v Value) MapKeys() []Value {
		value.go#L1844: 	a := make([]Value, mlen)
		value.go#L1889: 	m     Value
		value.go#L1894: func (iter *MapIter) Key() Value {
		value.go#L1912: func (v Value) SetIterKey(iter *MapIter) {
		value.go#L1931: 	key := Value{ktype, iterkey, iter.m.flag | flag(ktype.Kind()) | flagIndir}
		value.go#L1937: func (iter *MapIter) Value() Value {
		value.go#L1955: func (v Value) SetIterValue(iter *MapIter) {
		value.go#L1974: 	elem := Value{vtype, iterelem, iter.m.flag | flag(vtype.Kind()) | flagIndir}
		value.go#L2001: func (iter *MapIter) Reset(v Value) {
		value.go#L2024: func (v Value) MapRange() *MapIter {
		value.go#L2046: func copyVal(typ *abi.Type, fl flag, ptr unsafe.Pointer) Value {
		value.go#L2052: 		return Value{typ, c, fl | flagIndir}
		value.go#L2054: 	return Value{typ, *(*unsafe.Pointer)(ptr), fl}
		value.go#L2061: func (v Value) Method(i int) Value {
		value.go#L2074: 	return Value{v.typ(), v.ptr, fl}
		value.go#L2082: func (v Value) NumMethod() int {
		value.go#L2097: func (v Value) MethodByName(name string) Value {
		value.go#L2102: 		return Value{}
		value.go#L2106: 		return Value{}
		value.go#L2113: func (v Value) NumField() int {
		value.go#L2121: func (v Value) OverflowComplex(x complex128) bool {
		value.go#L2134: func (v Value) OverflowFloat(x float64) bool {
		value.go#L2154: func (v Value) OverflowInt(x int64) bool {
		value.go#L2167: func (v Value) OverflowUint(x uint64) bool {
		value.go#L2199: func (v Value) Pointer() uintptr {
		value.go#L2248: func (v Value) Recv() (x Value, ok bool) {
		value.go#L2256: func (v Value) recv(nb bool) (val Value, ok bool) {
		value.go#L2262: 	val = Value{t, nil, flag(t.Kind())}
		value.go#L2273: 		val = Value{}
		value.go#L2281: func (v Value) Send(x Value) {
		value.go#L2289: func (v Value) send(x Value, nb bool) (selected bool) {
		value.go#L2309: func (v Value) Set(x Value) {
		value.go#L2330: func (v Value) SetBool(x bool) {
		value.go#L2338: func (v Value) SetBytes(x []byte) {
		value.go#L2349: func (v Value) setRunes(x []rune) {
		value.go#L2360: func (v Value) SetComplex(x complex128) {
		value.go#L2374: func (v Value) SetFloat(x float64) {
		value.go#L2388: func (v Value) SetInt(x int64) {
		value.go#L2409: func (v Value) SetLen(n int) {
		value.go#L2422: func (v Value) SetCap(n int) {
		value.go#L2438: func (v Value) SetMapIndex(key, elem Value) {
		value.go#L2486: func (v Value) SetUint(x uint64) {
		value.go#L2508: func (v Value) SetPointer(x unsafe.Pointer) {
		value.go#L2516: func (v Value) SetString(x string) {
		value.go#L2525: func (v Value) Slice(i, j int) Value {
		value.go#L2559: 		return Value{v.typ(), unsafe.Pointer(&t), v.flag}
		value.go#L2581: 	return Value{typ.Common(), unsafe.Pointer(&x), fl}
		value.go#L2587: func (v Value) Slice3(i, j, k int) Value {
		value.go#L2633: 	return Value{typ.Common(), unsafe.Pointer(&x), fl}
		value.go#L2642: func (v Value) String() string {
		value.go#L2650: func (v Value) stringNonString() string {
		value.go#L2664: func (v Value) TryRecv() (x Value, ok bool) {
		value.go#L2674: func (v Value) TrySend(x Value) bool {
		value.go#L2681: func (v Value) Type() Type {
		value.go#L2689: func (v Value) typeSlow() Type {
		value.go#L2693: func (v Value) abiType() *abi.Type {
		value.go#L2700: func (v Value) abiTypeSlow() *abi.Type {
		value.go#L2732: func (v Value) CanUint() bool {
		value.go#L2743: func (v Value) Uint() uint64 {
		value.go#L2772: func (v Value) UnsafeAddr() uintptr {
		value.go#L2798: func (v Value) UnsafePointer() unsafe.Pointer {
		value.go#L2889: func (v Value) Grow(n int) {
		value.go#L2896: func (v Value) grow(n int) {
		value.go#L2915: func (v Value) extendSlice(n int) Value {
		value.go#L2933: func (v Value) Clear() {
		value.go#L2948: func Append(s Value, x ...Value) Value {
		value.go#L2960: func AppendSlice(s, t Value) Value {
		value.go#L2978: func Copy(dst, src Value) int {
		value.go#L3080: 	Chan Value     // channel to use (for send or receive)
		value.go#L3081: 	Send Value     // value to send (for send)
		value.go#L3092: func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) {
		value.go#L3183: 			recv = Value{t, p, fl | flagIndir}
		value.go#L3185: 			recv = Value{t, *(*unsafe.Pointer)(p), fl}
		value.go#L3205: func MakeSlice(typ Type, len, cap int) Value {
		value.go#L3220: 	return Value{&typ.(*rtype).t, unsafe.Pointer(&s), flagIndir | flag(Slice)}
		value.go#L3227: func SliceAt(typ Type, p unsafe.Pointer, n int) Value {
		value.go#L3230: 	return Value{SliceOf(typ).common(), unsafe.Pointer(&s), flagIndir | flag(Slice)}
		value.go#L3234: func MakeChan(typ Type, buffer int) Value {
		value.go#L3246: 	return Value{t, ch, flag(Chan)}
		value.go#L3250: func MakeMap(typ Type) Value {
		value.go#L3256: func MakeMapWithSize(typ Type, n int) Value {
		value.go#L3262: 	return Value{t, m, flag(Map)}
		value.go#L3268: func Indirect(v Value) Value {
		value.go#L3277: func ValueOf(i any) Value {
		value.go#L3279: 		return Value{}
		value.go#L3289: func Zero(typ Type) Value {
		value.go#L3302: 		return Value{t, p, fl | flagIndir}
		value.go#L3304: 	return Value{t, nil, fl}
		value.go#L3312: func New(typ Type) Value {
		value.go#L3324: 	return Value{pt, ptr, fl}
		value.go#L3329: func NewAt(typ Type, p unsafe.Pointer) Value {
		value.go#L3332: 	return Value{t.ptrTo(), p, fl}
		value.go#L3340: func (v Value) assignTo(context string, dst *abi.Type, target unsafe.Pointer) Value {
		value.go#L3351: 		return Value{dst, v.ptr, fl}
		value.go#L3358: 			return Value{dst, nil, flag(Interface)}
		value.go#L3369: 		return Value{dst, target, flagIndir | flag(Interface)}
		value.go#L3379: func (v Value) Convert(t Type) Value {
		value.go#L3392: func (v Value) CanConvert(t Type) bool {
		value.go#L3417: func (v Value) Comparable() bool {
		value.go#L3459: func (v Value) Equal(u Value) bool {
		value.go#L3527: func convertOp(dst, src *abi.Type) func(Value, Type) Value {
		value.go#L3625: func makeInt(f flag, bits uint64, t Type) Value {
		value.go#L3638: 	return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
		value.go#L3643: func makeFloat(f flag, v float64, t Type) Value {
		value.go#L3652: 	return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
		value.go#L3656: func makeFloat32(f flag, v float32, t Type) Value {
		value.go#L3660: 	return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
		value.go#L3665: func makeComplex(f flag, v complex128, t Type) Value {
		value.go#L3674: 	return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
		value.go#L3677: func makeString(f flag, v string, t Type) Value {
		value.go#L3684: func makeBytes(f flag, v []byte, t Type) Value {
		value.go#L3691: func makeRunes(f flag, v []rune, t Type) Value {
		value.go#L3704: func cvtInt(v Value, t Type) Value {
		value.go#L3709: func cvtUint(v Value, t Type) Value {
		value.go#L3714: func cvtFloatInt(v Value, t Type) Value {
		value.go#L3719: func cvtFloatUint(v Value, t Type) Value {
		value.go#L3724: func cvtIntFloat(v Value, t Type) Value {
		value.go#L3729: func cvtUintFloat(v Value, t Type) Value {
		value.go#L3734: func cvtFloat(v Value, t Type) Value {
		value.go#L3745: func cvtComplex(v Value, t Type) Value {
		value.go#L3750: func cvtIntString(v Value, t Type) Value {
		value.go#L3759: func cvtUintString(v Value, t Type) Value {
		value.go#L3768: func cvtBytesString(v Value, t Type) Value {
		value.go#L3773: func cvtStringBytes(v Value, t Type) Value {
		value.go#L3778: func cvtRunesString(v Value, t Type) Value {
		value.go#L3783: func cvtStringRunes(v Value, t Type) Value {
		value.go#L3788: func cvtSliceArrayPtr(v Value, t Type) Value {
		value.go#L3794: 	return Value{t.common(), h.Data, v.flag&^(flagIndir|flagAddr|flagKindMask) | flag(Pointer)}
		value.go#L3798: func cvtSliceArray(v Value, t Type) Value {
		value.go#L3810: 	return Value{typ, ptr, v.flag&^(flagAddr|flagKindMask) | flag(Array)}
		value.go#L3814: func cvtDirect(v Value, typ Type) Value {
		value.go#L3825: 	return Value{t, ptr, v.flag.ro() | f} // v.flag.ro()|f == f?
		value.go#L3829: func cvtT2I(v Value, typ Type) Value {
		value.go#L3837: 	return Value{typ.common(), target, v.flag.ro() | flagIndir | flag(Interface)}
		value.go#L3841: func cvtI2I(v Value, typ Type) Value {

	encoding/asn1
		asn1.go#L608: func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
		asn1.go#L678: func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err error) {
		asn1.go#L1008: func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
		marshal.go#L458: func makeBody(value reflect.Value, params fieldParameters) (e encoder, err error) {
		marshal.go#L576: func makeField(v reflect.Value, params fieldParameters) (e encoder, err error) {

	encoding/binary
		binary.go#L680: func dataSize(v reflect.Value) int {
		binary.go#L827: func (d *decoder) value(v reflect.Value) {
		binary.go#L896: func (e *encoder) value(v reflect.Value) {
		binary.go#L959: func (d *decoder) skip(v reflect.Value) {
		binary.go#L963: func (e *encoder) skip(v reflect.Value) {

	encoding/json
		decode.go#L357: func (d *decodeState) value(v reflect.Value) error {
		decode.go#L426: func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
		decode.go#L480: 				return u, nil, reflect.Value{}
		decode.go#L484: 					return nil, u, reflect.Value{}
		decode.go#L501: func (d *decodeState) array(v reflect.Value) error {
		decode.go#L560: 			if err := d.value(reflect.Value{}); err != nil {
		decode.go#L598: func (d *decodeState) object(v reflect.Value) error {
		decode.go#L654: 	var mapElem reflect.Value
		decode.go#L681: 		var subv reflect.Value
		decode.go#L712: 								subv = reflect.Value{}
		decode.go#L764: 			var kv reflect.Value
		decode.go#L844: func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
		encode.go#L208: 	Value reflect.Value
		encode.go#L307: func isEmptyValue(v reflect.Value) bool {
		encode.go#L321: func (e *encodeState) reflectValue(v reflect.Value, opts encOpts) {
		encode.go#L332: type encoderFunc func(e *encodeState, v reflect.Value, opts encOpts)
		encode.go#L336: func valueEncoder(v reflect.Value) encoderFunc {
		encode.go#L357: 	fi, loaded := encoderCache.LoadOrStore(t, encoderFunc(func(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L427: func invalidValueEncoder(e *encodeState, v reflect.Value, _ encOpts) {
		encode.go#L431: func marshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L453: func addrMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L472: func textMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L489: func addrTextMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L503: func boolEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L511: func intEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L519: func uintEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L529: func (bits floatEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L568: func stringEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L664: func interfaceEncoder(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L672: func unsupportedTypeEncoder(e *encodeState, v reflect.Value, _ encOpts) {
		encode.go#L686: func (se structEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L733: func (me mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L792: func encodeByteSlice(e *encodeState, v reflect.Value, _ encOpts) {
		encode.go#L811: func (se sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L851: func (ae arrayEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L872: func (pe ptrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L900: func (ce condAddrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
		encode.go#L943: 	v  reflect.Value
		encode.go#L947: func resolveKeyName(k reflect.Value) (string, error) {

	fmt
		print.go#L127: 	value reflect.Value
		print.go#L179: 	p.value = reflect.Value{}
		print.go#L341: func getField(v reflect.Value, i int) reflect.Value {
		print.go#L371: func (p *pp) unknownType(v reflect.Value) {
		print.go#L549: func (p *pp) fmtPointer(value reflect.Value, verb rune) {
		print.go#L683: 	p.value = reflect.Value{}
		print.go#L744: 	case reflect.Value:
		print.go#L766: func (p *pp) printValue(value reflect.Value, verb rune, depth int) {

	github.com/oapi-codegen/runtime
		bindform.go#L125: func bindFormImpl(v reflect.Value, form map[string][]string, files map[string][]*multipart.FileHeader, name string) (bool, error) {
		bindform.go#L234: func bindAdditionalProperties(additionalProperties reflect.Value, parentStruct reflect.Value, form map[string][]string, files map[string][]*multipart.FileHeader, name string) (bool, error) {
		bindform.go#L289: func marshalFormImpl(v reflect.Value, result url.Values, name string) {
		bindparam.go#L535: func indirect(dest interface{}) (interface{}, reflect.Value, reflect.Type) {
		bindparam.go#L539: 			return u, reflect.Value{}, nil
		bindparam.go#L549: 		return dest, reflect.Value{}, nil
		bindparam.go#L552: 		return dest, reflect.Value{}, nil
		deepobject.go#L337: func assignSlice(dst reflect.Value, pathValues fieldOrValue) error {

	internal/fmtsort
		sort.go#L28: 	Key, Value reflect.Value
		sort.go#L49: func Sort(mapValue reflect.Value) SortedMap {
		sort.go#L72: func compare(aVal, bVal reflect.Value) int {
		sort.go#L143: func nilCompare(aVal, bVal reflect.Value) (int, bool) {

	net/http/httptrace
		trace.go#L202: 		newFunc := reflect.MakeFunc(hookType, func(args []reflect.Value) []reflect.Value {