type reflect.Value
988 uses
reflect (current package)
deepequal.go#L24: func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool {
deepequal.go#L36: hard := func(v1, v2 Value) bool {
deepequal.go#L60: ptrval := func(v Value) unsafe.Pointer {
makefunc.go#L23: fn func([]Value) []Value
makefunc.go#L48: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
makefunc.go#L67: return Value{t, unsafe.Pointer(impl), flag(Func)}
makefunc.go#L85: rcvr Value
makefunc.go#L95: func makeMethodValue(op string, v Value) Value {
makefunc.go#L103: rcvr := Value{v.typ, v.ptr, fl}
makefunc.go#L130: return Value{&ftyp.rtype, unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
type.go#L580: Func Value // func with receiver as first argument
type.go#L830: m.Func = Value{mt.(*rtype), fn, fl}
type.go#L2436: ifn Value
type.go#L2437: tfn Value
type.go#L2441: tfn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2442: var args []Value
type.go#L2449: ifn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2450: var args []Value
type.go#L2458: tfn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2459: var args []Value
type.go#L2466: ifn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2467: var args []Value
value.go#L37: type Value struct {
value.go#L94: func (v Value) pointer() unsafe.Pointer {
value.go#L105: func packEface(v Value) interface{} {
value.go#L142: func unpackEface(i interface{}) Value {
value.go#L147: return Value{}
value.go#L153: return Value{t, e.word, f}
value.go#L269: func (v Value) Addr() Value {
value.go#L276: return Value{v.typ.ptrTo(), v.ptr, fl | flag(Ptr)}
value.go#L281: func (v Value) Bool() bool {
value.go#L288: func (v Value) Bytes() []byte {
value.go#L299: func (v Value) runes() []rune {
value.go#L313: func (v Value) CanAddr() bool {
value.go#L322: func (v Value) CanSet() bool {
value.go#L334: func (v Value) Call(in []Value) []Value {
value.go#L347: func (v Value) CallSlice(in []Value) []Value {
value.go#L355: func (v Value) call(op string, in []Value) []Value {
value.go#L360: rcvr Value
value.go#L422: in = make([]Value, n+1)
value.go#L483: var ret []Value
value.go#L494: ret = make([]Value, nout)
value.go#L502: ret[i] = Value{tv.common(), add(args, off, "tv.Size() != 0"), fl}
value.go#L543: in := make([]Value, 0, int(ftyp.inCount))
value.go#L546: v := Value{typ, nil, flag(typ.Kind())}
value.go#L635: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer) {
value.go#L674: func storeRcvr(v Value, p unsafe.Pointer) {
value.go#L761: func funcName(f func([]Value) []Value) string {
value.go#L772: func (v Value) Cap() int {
value.go#L788: func (v Value) Close() {
value.go#L796: func (v Value) Complex() complex128 {
value.go#L811: func (v Value) Elem() Value {
value.go#L835: return Value{}
value.go#L841: return Value{typ, ptr, fl}
value.go#L848: func (v Value) Field(i int) Value {
value.go#L875: return Value{typ, ptr, fl}
value.go#L880: func (v Value) FieldByIndex(index []int) Value {
value.go#L902: func (v Value) FieldByName(name string) Value {
value.go#L907: return Value{}
value.go#L914: func (v Value) FieldByNameFunc(match func(string) bool) Value {
value.go#L918: return Value{}
value.go#L923: func (v Value) Float() float64 {
value.go#L938: func (v Value) Index(i int) Value {
value.go#L955: return Value{typ, val, fl}
value.go#L968: return Value{typ, val, fl}
value.go#L977: return Value{uint8Type, p, fl}
value.go#L984: func (v Value) Int() int64 {
value.go#L1003: func (v Value) CanInterface() bool {
value.go#L1015: func (v Value) Interface() (i interface{}) {
value.go#L1019: func valueInterface(v Value, safe bool) interface{} {
value.go#L1051: func (v Value) InterfaceData() [2]uintptr {
value.go#L1069: func (v Value) IsNil() bool {
value.go#L1094: func (v Value) IsValid() bool {
value.go#L1100: func (v Value) IsZero() bool {
value.go#L1140: func (v Value) Kind() Kind {
value.go#L1146: func (v Value) Len() int {
value.go#L1170: func (v Value) MapIndex(key Value) Value {
value.go#L1191: return Value{}
value.go#L1203: func (v Value) MapKeys() []Value {
value.go#L1216: a := make([]Value, mlen)
value.go#L1235: m Value
value.go#L1240: func (it *MapIter) Key() Value {
value.go#L1254: func (it *MapIter) Value() Value {
value.go#L1298: func (v Value) MapRange() *MapIter {
value.go#L1305: func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value {
value.go#L1311: return Value{typ, c, fl | flagIndir}
value.go#L1313: return Value{typ, *(*unsafe.Pointer)(ptr), fl}
value.go#L1320: func (v Value) Method(i int) Value {
value.go#L1333: return Value{v.typ, v.ptr, fl}
value.go#L1337: func (v Value) NumMethod() int {
value.go#L1352: func (v Value) MethodByName(name string) Value {
value.go#L1357: return Value{}
value.go#L1361: return Value{}
value.go#L1368: func (v Value) NumField() int {
value.go#L1376: func (v Value) OverflowComplex(x complex128) bool {
value.go#L1389: func (v Value) OverflowFloat(x float64) bool {
value.go#L1409: func (v Value) OverflowInt(x int64) bool {
value.go#L1422: func (v Value) OverflowUint(x uint64) bool {
value.go#L1452: func (v Value) Pointer() uintptr {
value.go#L1497: func (v Value) Recv() (x Value, ok bool) {
value.go#L1505: func (v Value) recv(nb bool) (val Value, ok bool) {
value.go#L1511: val = Value{t, nil, flag(t.Kind())}
value.go#L1522: val = Value{}
value.go#L1530: func (v Value) Send(x Value) {
value.go#L1538: func (v Value) send(x Value, nb bool) (selected bool) {
value.go#L1557: func (v Value) Set(x Value) {
value.go#L1578: func (v Value) SetBool(x bool) {
value.go#L1586: func (v Value) SetBytes(x []byte) {
value.go#L1597: func (v Value) setRunes(x []rune) {
value.go#L1608: func (v Value) SetComplex(x complex128) {
value.go#L1622: func (v Value) SetFloat(x float64) {
value.go#L1636: func (v Value) SetInt(x int64) {
value.go#L1657: func (v Value) SetLen(n int) {
value.go#L1670: func (v Value) SetCap(n int) {
value.go#L1686: func (v Value) SetMapIndex(key, elem Value) {
value.go#L1715: func (v Value) SetUint(x uint64) {
value.go#L1737: func (v Value) SetPointer(x unsafe.Pointer) {
value.go#L1745: func (v Value) SetString(x string) {
value.go#L1754: func (v Value) Slice(i, j int) Value {
value.go#L1788: return Value{v.typ, unsafe.Pointer(&t), v.flag}
value.go#L1810: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L1816: func (v Value) Slice3(i, j, k int) Value {
value.go#L1862: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L1871: func (v Value) String() string {
value.go#L1888: func (v Value) TryRecv() (x Value, ok bool) {
value.go#L1898: func (v Value) TrySend(x Value) bool {
value.go#L1905: func (v Value) Type() Type {
value.go#L1938: func (v Value) Uint() uint64 {
value.go#L1966: func (v Value) UnsafeAddr() uintptr {
value.go#L2019: func grow(s Value, extra int) (Value, int, int) {
value.go#L2047: func Append(s Value, x ...Value) Value {
value.go#L2058: func AppendSlice(s, t Value) Value {
value.go#L2074: func Copy(dst, src Value) int {
value.go#L2171: Chan Value // channel to use (for send or receive)
value.go#L2172: Send Value // value to send (for send)
value.go#L2183: func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) {
value.go#L2271: recv = Value{t, p, fl | flagIndir}
value.go#L2273: recv = Value{t, *(*unsafe.Pointer)(p), fl}
value.go#L2289: func MakeSlice(typ Type, len, cap int) Value {
value.go#L2304: return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L2308: func MakeChan(typ Type, buffer int) Value {
value.go#L2320: return Value{t, ch, flag(Chan)}
value.go#L2324: func MakeMap(typ Type) Value {
value.go#L2330: func MakeMapWithSize(typ Type, n int) Value {
value.go#L2336: return Value{t, m, flag(Map)}
value.go#L2342: func Indirect(v Value) Value {
value.go#L2351: func ValueOf(i interface{}) Value {
value.go#L2353: return Value{}
value.go#L2370: func Zero(typ Type) Value {
value.go#L2383: return Value{t, p, fl | flagIndir}
value.go#L2385: return Value{t, nil, fl}
value.go#L2396: func New(typ Type) Value {
value.go#L2403: return Value{t.ptrTo(), ptr, fl}
value.go#L2408: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L2411: return Value{t.ptrTo(), p, fl}
value.go#L2418: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
value.go#L2429: return Value{dst, v.ptr, fl}
value.go#L2439: return Value{dst, nil, flag(Interface)}
value.go#L2447: return Value{dst, target, flagIndir | flag(Interface)}
value.go#L2457: func (v Value) Convert(t Type) Value {
value.go#L2470: func convertOp(dst, src *rtype) func(Value, Type) Value {
value.go#L2558: func makeInt(f flag, bits uint64, t Type) Value {
value.go#L2571: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L2576: func makeFloat(f flag, v float64, t Type) Value {
value.go#L2585: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L2589: func makeFloat32(f flag, v float32, t Type) Value {
value.go#L2593: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L2598: func makeComplex(f flag, v complex128, t Type) Value {
value.go#L2607: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L2610: func makeString(f flag, v string, t Type) Value {
value.go#L2617: func makeBytes(f flag, v []byte, t Type) Value {
value.go#L2624: func makeRunes(f flag, v []rune, t Type) Value {
value.go#L2637: func cvtInt(v Value, t Type) Value {
value.go#L2642: func cvtUint(v Value, t Type) Value {
value.go#L2647: func cvtFloatInt(v Value, t Type) Value {
value.go#L2652: func cvtFloatUint(v Value, t Type) Value {
value.go#L2657: func cvtIntFloat(v Value, t Type) Value {
value.go#L2662: func cvtUintFloat(v Value, t Type) Value {
value.go#L2667: func cvtFloat(v Value, t Type) Value {
value.go#L2678: func cvtComplex(v Value, t Type) Value {
value.go#L2683: func cvtIntString(v Value, t Type) Value {
value.go#L2692: func cvtUintString(v Value, t Type) Value {
value.go#L2701: func cvtBytesString(v Value, t Type) Value {
value.go#L2706: func cvtStringBytes(v Value, t Type) Value {
value.go#L2711: func cvtRunesString(v Value, t Type) Value {
value.go#L2716: func cvtStringRunes(v Value, t Type) Value {
value.go#L2721: func cvtDirect(v Value, typ Type) Value {
value.go#L2732: return Value{t, ptr, v.flag.ro() | f} // v.flag.ro()|f == f?
value.go#L2736: func cvtT2I(v Value, typ Type) Value {
value.go#L2744: return Value{typ.common(), target, v.flag.ro() | flagIndir | flag(Interface)}
value.go#L2748: func cvtI2I(v Value, typ Type) Value {
cloud.google.com/go/storage
acl.go#L232: vc.MethodByName("Context").Call([]reflect.Value{reflect.ValueOf(ctx)})
acl.go#L234: vc.MethodByName("UserProject").Call([]reflect.Value{reflect.ValueOf(a.userProject)})
storage.go#L1513: func setConditionField(call reflect.Value, name string, value interface{}) bool {
storage.go#L1518: m.Call([]reflect.Value{reflect.ValueOf(value)})
database/sql
convert.go#L348: var sv reflect.Value
convert.go#L521: func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
encoding/asn1
asn1.go#L605: func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
asn1.go#L675: func parseField(v reflect.Value, bytes []byte, initOffset int, params fieldParameters) (offset int, err error) {
asn1.go#L1005: func setDefaultValue(v reflect.Value, params fieldParameters) (ok bool) {
marshal.go#L461: func makeBody(value reflect.Value, params fieldParameters) (e encoder, err error) {
marshal.go#L579: func makeField(v reflect.Value, params fieldParameters) (e encoder, err error) {
encoding/binary
binary.go#L405: func dataSize(v reflect.Value) int {
binary.go#L540: func (d *decoder) value(v reflect.Value) {
binary.go#L609: func (e *encoder) value(v reflect.Value) {
binary.go#L684: func (d *decoder) skip(v reflect.Value) {
binary.go#L688: func (e *encoder) skip(v reflect.Value) {
encoding/gob
dec_helpers.go#L52: func decBoolArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L60: func decBoolSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L75: func decComplex64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L83: func decComplex64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L100: func decComplex128Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L108: func decComplex128Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L125: func decFloat32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L133: func decFloat32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L148: func decFloat64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L156: func decFloat64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L171: func decIntArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L179: func decIntSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L199: func decInt16Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L207: func decInt16Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L226: func decInt32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L234: func decInt32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L253: func decInt64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L261: func decInt64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L276: func decInt8Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L284: func decInt8Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L303: func decStringArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L311: func decStringSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L340: func decUintArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L348: func decUintSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L367: func decUint16Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L375: func decUint16Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L394: func decUint32Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L402: func decUint32Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L421: func decUint64Array(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L429: func decUint64Slice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L444: func decUintptrArray(state *decoderState, v reflect.Value, length int, ovfl error) bool {
dec_helpers.go#L452: func decUintptrSlice(state *decoderState, v reflect.Value, length int, ovfl error) bool {
decode.go#L24: type decHelper func(state *decoderState, v reflect.Value, length int, ovfl error) bool
decode.go#L197: type decOp func(i *decInstr, state *decoderState, v reflect.Value)
decode.go#L208: func ignoreUint(i *decInstr, state *decoderState, v reflect.Value) {
decode.go#L214: func ignoreTwoUints(i *decInstr, state *decoderState, v reflect.Value) {
decode.go#L230: func decAlloc(v reflect.Value) reflect.Value {
decode.go#L241: func decBool(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L246: func decInt8(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L255: func decUint8(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L264: func decInt16(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L273: func decUint16(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L282: func decInt32(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L291: func decUint32(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L300: func decInt64(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L306: func decUint64(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L340: func decFloat32(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L346: func decFloat64(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L353: func decComplex64(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L362: func decComplex128(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L371: func decUint8Slice(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L389: func decString(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L405: func ignoreUint8Array(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L429: func (dec *Decoder) decodeSingle(engine *decEngine, value reflect.Value) {
decode.go#L445: func (dec *Decoder) decodeStruct(engine *decEngine, value reflect.Value) {
decode.go#L463: var field reflect.Value
decode.go#L476: var noValue reflect.Value
decode.go#L516: func (dec *Decoder) decodeArrayHelper(state *decoderState, value reflect.Value, elemOp decOp, length int, ovfl error, helper decHelper) {
decode.go#L537: func (dec *Decoder) decodeArray(state *decoderState, value reflect.Value, elemOp decOp, length int, ovfl error, helper decHelper) {
decode.go#L545: func decodeIntoValue(state *decoderState, op decOp, isPtr bool, value reflect.Value, instr *decInstr) reflect.Value {
decode.go#L559: func (dec *Decoder) decodeMap(mtyp reflect.Type, state *decoderState, value reflect.Value, keyOp, elemOp decOp, ovfl error) {
decode.go#L613: func (dec *Decoder) decodeSlice(state *decoderState, value reflect.Value, elemOp decOp, ovfl error, helper decHelper) {
decode.go#L641: func (dec *Decoder) decodeInterface(ityp reflect.Type, state *decoderState, value reflect.Value) {
decode.go#L718: func (dec *Decoder) decodeGobDecoder(ut *userTypeInfo, state *decoderState, value reflect.Value) {
decode.go#L818: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L828: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L847: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L858: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L863: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L887: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L900: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L909: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L916: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L926: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L932: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L955: op = func(i *decInstr, state *decoderState, value reflect.Value) {
decode.go#L1181: func (dec *Decoder) decodeValue(wireId typeId, value reflect.Value) {
decode.go#L1257: func allocValue(t reflect.Type) reflect.Value {
decoder.go#L179: return dec.DecodeValue(reflect.Value{})
decoder.go#L197: func (dec *Decoder) DecodeValue(v reflect.Value) error {
enc_helpers.go#L51: func encBoolArray(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L59: func encBoolSlice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L77: func encComplex64Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L85: func encComplex64Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L102: func encComplex128Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L110: func encComplex128Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L127: func encFloat32Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L135: func encFloat32Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L150: func encFloat64Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L158: func encFloat64Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L173: func encIntArray(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L181: func encIntSlice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L195: func encInt16Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L203: func encInt16Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L217: func encInt32Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L225: func encInt32Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L239: func encInt64Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L247: func encInt64Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L261: func encInt8Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L269: func encInt8Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L283: func encStringArray(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L291: func encStringSlice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L306: func encUintArray(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L314: func encUintSlice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L328: func encUint16Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L336: func encUint16Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L350: func encUint32Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L358: func encUint32Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L372: func encUint64Array(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L380: func encUint64Slice(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L394: func encUintptrArray(state *encoderState, v reflect.Value) bool {
enc_helpers.go#L402: func encUintptrSlice(state *encoderState, v reflect.Value) bool {
encode.go#L20: type encHelper func(state *encoderState, v reflect.Value) bool
encode.go#L134: type encOp func(i *encInstr, state *encoderState, v reflect.Value)
encode.go#L163: func encIndirect(pv reflect.Value, indir int) reflect.Value {
encode.go#L174: func encBool(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L187: func encInt(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L196: func encUint(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L216: func encFloat(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L227: func encComplex(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L240: func encUint8Array(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L251: func encString(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L262: func encStructTerminator(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L278: func valid(v reflect.Value) bool {
encode.go#L289: func (enc *Encoder) encodeSingle(b *encBuffer, engine *encEngine, value reflect.Value) {
encode.go#L306: func (enc *Encoder) encodeStruct(b *encBuffer, engine *encEngine, value reflect.Value) {
encode.go#L317: instr.op(instr, state, reflect.Value{})
encode.go#L333: func (enc *Encoder) encodeArray(b *encBuffer, value reflect.Value, op encOp, elemIndir int, length int, helper encHelper) {
encode.go#L356: func encodeReflectValue(state *encoderState, v reflect.Value, op encOp, indir int) {
encode.go#L367: func (enc *Encoder) encodeMap(b *encBuffer, mv reflect.Value, keyOp, elemOp encOp, keyIndir, elemIndir int) {
encode.go#L385: func (enc *Encoder) encodeInterface(b *encBuffer, iv reflect.Value) {
encode.go#L434: func isZero(val reflect.Value) bool {
encode.go#L470: func (enc *Encoder) encodeGobEncoder(b *encBuffer, ut *userTypeInfo, v reflect.Value) {
encode.go#L546: op = func(i *encInstr, state *encoderState, slice reflect.Value) {
encode.go#L557: op = func(i *encInstr, state *encoderState, array reflect.Value) {
encode.go#L564: op = func(i *encInstr, state *encoderState, mv reflect.Value) {
encode.go#L577: op = func(i *encInstr, state *encoderState, sv reflect.Value) {
encode.go#L584: op = func(i *encInstr, state *encoderState, iv reflect.Value) {
encode.go#L610: op = func(i *encInstr, state *encoderState, v reflect.Value) {
encode.go#L690: func (enc *Encoder) encode(b *encBuffer, value reflect.Value, ut *userTypeInfo) {
encoder.go#L218: func (enc *Encoder) EncodeValue(value reflect.Value) error {
encoding/json
decode.go#L353: func (d *decodeState) value(v reflect.Value) error {
decode.go#L422: func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
decode.go#L476: return u, nil, reflect.Value{}
decode.go#L480: return nil, u, reflect.Value{}
decode.go#L497: func (d *decodeState) array(v reflect.Value) error {
decode.go#L563: if err := d.value(reflect.Value{}); err != nil {
decode.go#L603: func (d *decodeState) object(v reflect.Value) error {
decode.go#L659: var mapElem reflect.Value
decode.go#L683: var subv reflect.Value
decode.go#L725: subv = reflect.Value{}
decode.go#L774: var kv reflect.Value
decode.go#L850: func (d *decodeState) literalStore(item []byte, v reflect.Value, fromQuoted bool) error {
encode.go#L242: Value reflect.Value
encode.go#L341: func isEmptyValue(v reflect.Value) bool {
encode.go#L359: func (e *encodeState) reflectValue(v reflect.Value, opts encOpts) {
encode.go#L370: type encoderFunc func(e *encodeState, v reflect.Value, opts encOpts)
encode.go#L374: func valueEncoder(v reflect.Value) encoderFunc {
encode.go#L395: fi, loaded := encoderCache.LoadOrStore(t, encoderFunc(func(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L465: func invalidValueEncoder(e *encodeState, v reflect.Value, _ encOpts) {
encode.go#L469: func marshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L489: func addrMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L506: func textMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L523: func addrTextMarshalerEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L537: func boolEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L551: func intEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L562: func uintEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L575: func (bits floatEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L619: func stringEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L711: func interfaceEncoder(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L719: func unsupportedTypeEncoder(e *encodeState, v reflect.Value, _ encOpts) {
encode.go#L732: func (se structEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L779: func (me mapEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L833: func encodeByteSlice(e *encodeState, v reflect.Value, _ encOpts) {
encode.go#L868: func (se sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L908: func (ae arrayEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L929: func (pe ptrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L957: func (ce condAddrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L1000: v reflect.Value
encoding/xml
marshal.go#L408: func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo, startTemplate *StartElement) error {
marshal.go#L553: func (p *printer) marshalAttr(start *StartElement, name Name, val reflect.Value) error {
marshal.go#L754: func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
marshal.go#L795: func indirect(vf reflect.Value) reflect.Value {
marshal.go#L805: func (p *printer) marshalStruct(tinfo *typeInfo, val reflect.Value) error {
marshal.go#L1042: func isEmptyValue(v reflect.Value) bool {
read.go#L246: func (d *Decoder) unmarshalAttr(val reflect.Value, attr Attr) error {
read.go#L308: func (d *Decoder) unmarshal(val reflect.Value, start *StartElement) error {
read.go#L365: saveData reflect.Value
read.go#L367: saveComment reflect.Value
read.go#L368: saveXML reflect.Value
read.go#L371: saveAny reflect.Value
read.go#L372: sv reflect.Value
read.go#L566: saveData = reflect.Value{}
read.go#L575: saveData = reflect.Value{}
read.go#L602: func copyValue(dst reflect.Value, src []byte) (err error) {
read.go#L675: func (d *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) {
typeinfo.go#L357: func (finfo *fieldInfo) value(v reflect.Value, shouldInitNilPointers bool) reflect.Value {
typeinfo.go#L364: return reflect.Value{}
flag
flag.go#L458: var z reflect.Value
fmt
print.go#L112: value reflect.Value
print.go#L159: p.value = reflect.Value{}
print.go#L290: func getField(v reflect.Value, i int) reflect.Value {
print.go#L320: func (p *pp) unknownType(v reflect.Value) {
print.go#L498: func (p *pp) fmtPointer(value reflect.Value, verb rune) {
print.go#L636: p.value = reflect.Value{}
print.go#L697: case reflect.Value:
print.go#L719: func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
github.com/aws/aws-sdk-go/aws/awsutil
copy.go#L37: func rcopy(dst, src reflect.Value, root bool) {
path_value.go#L16: func rValuesAtPath(v interface{}, path string, createPath, caseSensitive, nilTerm bool) []reflect.Value {
path_value.go#L28: values := []reflect.Value{reflect.Indirect(reflect.ValueOf(v))}
path_value.go#L54: nextvals := []reflect.Value{}
path_value.go#L83: return []reflect.Value{value}
path_value.go#L108: nextvals = []reflect.Value{}
path_value.go#L197: func setValue(dstVal reflect.Value, src interface{}) {
prettify.go#L20: func prettify(v reflect.Value, indent int, buf *bytes.Buffer) {
string_value.go#L17: func stringValue(v reflect.Value, indent int, buf *bytes.Buffer) {
github.com/aws/aws-sdk-go/private/protocol
idempotency.go#L20: func CanSetIdempotencyToken(v reflect.Value, f reflect.StructField) bool {
idempotency.go#L43: func SetIdempotencyToken(v reflect.Value) {
github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
build.go#L30: func buildAny(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
build.go#L75: func buildStruct(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
build.go#L152: func buildList(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
build.go#L168: type sortedValues []reflect.Value
build.go#L174: func buildMap(value reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
build.go#L196: func buildScalar(v reflect.Value, buf *bytes.Buffer, tag reflect.StructTag) error {
build.go#L291: func elemOf(value reflect.Value) reflect.Value {
unmarshal.go#L80: func (u unmarshaler) unmarshalAny(value reflect.Value, data interface{}, tag reflect.StructTag) error {
unmarshal.go#L122: func (u unmarshaler) unmarshalStruct(value reflect.Value, data interface{}, tag reflect.StructTag) error {
unmarshal.go#L180: func (u unmarshaler) unmarshalList(value reflect.Value, data interface{}, tag reflect.StructTag) error {
unmarshal.go#L204: func (u unmarshaler) unmarshalMap(value reflect.Value, data interface{}, tag reflect.StructTag) error {
unmarshal.go#L228: func (u unmarshaler) unmarshalScalar(value reflect.Value, data interface{}, tag reflect.StructTag) error {
github.com/aws/aws-sdk-go/private/protocol/query/queryutil
queryutil.go#L23: func elemOf(value reflect.Value) reflect.Value {
queryutil.go#L34: func (q *queryParser) parseValue(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
queryutil.go#L66: func (q *queryParser) parseStruct(v url.Values, value reflect.Value, prefix string) error {
queryutil.go#L117: func (q *queryParser) parseList(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
queryutil.go#L151: func (q *queryParser) parseMap(v url.Values, value reflect.Value, prefix string, tag reflect.StructTag) error {
queryutil.go#L166: mapKeys := map[string]reflect.Value{}
queryutil.go#L216: func (q *queryParser) parseScalar(v url.Values, r reflect.Value, name string, tag reflect.StructTag) error {
github.com/aws/aws-sdk-go/private/protocol/rest
build.go#L65: func buildLocationElements(r *request.Request, v reflect.Value, buildGETQuery bool) {
build.go#L135: func buildBody(r *request.Request, v reflect.Value) {
build.go#L160: func buildHeader(header *http.Header, v reflect.Value, name string, tag reflect.StructTag) error {
build.go#L176: func buildHeaderMap(header *http.Header, v reflect.Value, tag reflect.StructTag) error {
build.go#L194: func buildURI(u *url.URL, v reflect.Value, name string, tag reflect.StructTag) error {
build.go#L211: func buildQueryString(query url.Values, v reflect.Value, name string, tag reflect.StructTag) error {
build.go#L267: func convertType(v reflect.Value, tag reflect.StructTag) (str string, err error) {
unmarshal.go#L60: func unmarshalBody(r *request.Request, v reflect.Value) error {
unmarshal.go#L116: func unmarshalLocationElements(resp *http.Response, v reflect.Value, lowerCaseHeaderMaps bool) error {
unmarshal.go#L152: func unmarshalStatusCode(v reflect.Value, statusCode int) {
unmarshal.go#L164: func unmarshalHeaderMap(r reflect.Value, headers http.Header, prefix string, normalize bool) error {
unmarshal.go#L189: func unmarshalHeader(v reflect.Value, header string, tag reflect.StructTag) error {
github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
build.go#L38: func elemOf(value reflect.Value) reflect.Value {
build.go#L56: func (b *xmlBuilder) buildValue(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
build.go#L101: func (b *xmlBuilder) buildStruct(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
build.go#L180: func (b *xmlBuilder) buildList(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
build.go#L222: func (b *xmlBuilder) buildMap(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
build.go#L276: func (b *xmlBuilder) buildScalar(value reflect.Value, current *XMLNode, tag reflect.StructTag) error {
unmarshal.go#L66: func parse(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
unmarshal.go#L115: func parseStruct(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
unmarshal.go#L170: func parseList(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
unmarshal.go#L209: func parseMap(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
unmarshal.go#L226: func parseMapEntry(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
unmarshal.go#L255: func parseScalar(r reflect.Value, node *XMLNode, tag reflect.StructTag) error {
github.com/ghodss/yaml
fields.go#L22: func indirect(v reflect.Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
fields.go#L56: return u, nil, reflect.Value{}
fields.go#L59: return nil, u, reflect.Value{}
yaml.go#L77: func yamlToJSON(y []byte, jsonTarget *reflect.Value) ([]byte, error) {
yaml.go#L98: func convertToJSONableObject(yamlObj interface{}, jsonTarget *reflect.Value) (interface{}, error) {
yaml.go#L226: var jsonSliceElemValue *reflect.Value
github.com/go-git/gcfg
set.go#L34: func fieldFold(v reflect.Value, name string) (reflect.Value, tag) {
set.go#L53: return reflect.Value{}, tag{}
set.go#L195: func newValue(c *warnings.Collector, sect string, vCfg reflect.Value,
set.go#L196: vType reflect.Type) (reflect.Value, error) {
set.go#L278: var vVal reflect.Value
set.go#L300: var vAddr reflect.Value
github.com/go-redis/redis/v8/internal/proto
scan.go#L135: func makeSliceNextElemFunc(v reflect.Value) func() reflect.Value {
scan.go#L140: return func() reflect.Value {
scan.go#L157: return func() reflect.Value {
github.com/golang/protobuf/proto
properties.go#L264: oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[3].Interface().([]interface{})
properties.go#L267: oneofWrappers = fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0].Interface().([]interface{})
github.com/google/go-cmp/cmp
compare.go#L300: func (s *state) tryOptions(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L309: func (s *state) tryMethod(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L321: func (s *state) callTRFunc(f, v reflect.Value, step Transform) reflect.Value {
compare.go#L324: return f.Call([]reflect.Value{v})[0]
compare.go#L330: c := make(chan reflect.Value)
compare.go#L333: want := f.Call([]reflect.Value{v})[0]
compare.go#L345: func (s *state) callTTBFunc(f, x, y reflect.Value) bool {
compare.go#L349: return f.Call([]reflect.Value{x, y})[0].Bool()
compare.go#L356: c := make(chan reflect.Value)
compare.go#L359: want := f.Call([]reflect.Value{x, y})[0].Bool()
compare.go#L366: func detectRaces(c chan<- reflect.Value, f reflect.Value, vs ...reflect.Value) {
compare.go#L367: var ret reflect.Value
compare.go#L378: func sanitizeValue(v reflect.Value, t reflect.Type) reflect.Value {
compare.go#L388: func (s *state) compareStruct(t reflect.Type, vx, vy reflect.Value) {
compare.go#L390: var vax, vay reflect.Value // Addressable versions of vx and vy
compare.go#L431: func (s *state) compareSlice(t reflect.Type, vx, vy reflect.Value) {
compare.go#L457: step.vx, step.xkey = reflect.Value{}, -1
compare.go#L462: step.vy, step.ykey = reflect.Value{}, -1
compare.go#L523: func (s *state) compareMap(t reflect.Type, vx, vy reflect.Value) {
compare.go#L565: func (s *state) comparePtr(t reflect.Type, vx, vy reflect.Value) {
compare.go#L582: func (s *state) compareInterface(t reflect.Type, vx, vy reflect.Value) {
compare.go#L675: func makeAddressable(v reflect.Value) reflect.Value {
export_unsafe.go#L22: func retrieveUnexportedField(v reflect.Value, f reflect.StructField, addr bool) reflect.Value {
options.go#L32: filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption
options.go#L42: apply(s *state, vx, vy reflect.Value)
options.go#L66: func (opts Options) filter(s *state, t reflect.Type, vx, vy reflect.Value) (out applicableOption) {
options.go#L87: func (opts Options) apply(s *state, _, _ reflect.Value) {
options.go#L132: func (f pathFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L175: fnc reflect.Value // func(T, T) bool
options.go#L179: func (f valuesFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L201: func (ignore) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption { return ignore{} }
options.go#L202: func (ignore) apply(s *state, _, _ reflect.Value) { s.report(true, reportByIgnore) }
options.go#L210: func (validator) filter(_ *state, _ reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L219: func (validator) apply(s *state, vx, vy reflect.Value) {
options.go#L299: fnc reflect.Value // func(T) R
options.go#L304: func (tr *transformer) filter(s *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L318: func (tr *transformer) apply(s *state, vx, vy reflect.Value) {
options.go#L357: fnc reflect.Value // func(T, T) bool
options.go#L362: func (cm *comparer) filter(_ *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L369: func (cm *comparer) apply(s *state, vx, vy reflect.Value) {
options.go#L412: func (exporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L518: func (reporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
path.go#L53: Values() (vx, vy reflect.Value)
path.go#L153: vx, vy reflect.Value
path.go#L157: func (ps pathStep) Values() (vx, vy reflect.Value) { return ps.vx, ps.vy }
path.go#L181: pvx, pvy reflect.Value // Parent values (always addressible)
path.go#L186: func (sf StructField) Values() (vx, vy reflect.Value) {
path.go#L217: func (si SliceIndex) Values() (vx, vy reflect.Value) { return si.vx, si.vy }
path.go#L257: key reflect.Value
path.go#L261: func (mi MapIndex) Values() (vx, vy reflect.Value) { return mi.vx, mi.vy }
path.go#L265: func (mi MapIndex) Key() reflect.Value { return mi.key }
path.go#L274: func (in Indirect) Values() (vx, vy reflect.Value) { return in.vx, in.vy }
path.go#L284: func (ta TypeAssertion) Values() (vx, vy reflect.Value) { return ta.vx, ta.vy }
path.go#L295: func (tf Transform) Values() (vx, vy reflect.Value) { return tf.vx, tf.vy }
path.go#L302: func (tf Transform) Func() reflect.Value { return tf.trans.fnc }
path.go#L354: func (p pointerPath) Push(vx, vy reflect.Value) (equal, visited bool) {
path.go#L369: func (p pointerPath) Pop(vx, vy reflect.Value) {
report_compare.go#L206: var formatKey func(reflect.Value) string
report_compare.go#L211: formatKey = func(v reflect.Value) string { return v.String() }
report_compare.go#L215: formatKey = func(reflect.Value) string { return "" }
report_compare.go#L219: formatKey = func(v reflect.Value) string { return formatMapKey(v, false, ptrs) }
report_compare.go#L282: var keys []reflect.Value // invariant: len(list) == len(keys)
report_compare.go#L322: keys = append(keys, reflect.Value{})
report_compare.go#L371: keys = append(keys, reflect.Value{})
report_compare.go#L380: seenKeys := map[string]reflect.Value{}
report_references.go#L36: func (ps *pointerReferences) PushPair(vx, vy reflect.Value, d diffMode, deref bool) (pp [2]value.Pointer) {
report_references.go#L55: func (ps *pointerReferences) Push(v reflect.Value) (p value.Pointer, seen bool) {
report_reflect.go#L107: func (opts formatOptions) FormatValue(v reflect.Value, parentKind reflect.Kind, ptrs *pointerReferences) (out textNode) {
report_reflect.go#L347: func formatMapKey(v reflect.Value, disambiguate bool, ptrs *pointerReferences) string {
report_slices.go#L129: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L218: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L231: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L263: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L321: vx, vy reflect.Value, chunkSize int, name string,
report_slices.go#L322: makeRec func(reflect.Value, diffMode) textRecord,
report_slices.go#L328: appendChunks := func(v reflect.Value, d diffMode) int {
report_value.go#L16: ValueX reflect.Value
report_value.go#L17: ValueY reflect.Value
report_value.go#L49: Key reflect.Value // Invalid for slice element
github.com/google/go-cmp/cmp/cmpopts
ignore.go#L169: if vx.IsValid() && vf.Call([]reflect.Value{vx})[0].Bool() {
ignore.go#L172: if vy.IsValid() && vf.Call([]reflect.Value{vy})[0].Bool() {
ignore.go#L198: if vx.IsValid() && vf.Call([]reflect.Value{k, vx})[0].Bool() {
ignore.go#L201: if vy.IsValid() && vf.Call([]reflect.Value{k, vy})[0].Bool() {
sort.go#L40: fnc reflect.Value // func(T, T) bool
sort.go#L66: func (ss sliceSorter) checkSort(v reflect.Value) {
sort.go#L80: func (ss sliceSorter) less(v reflect.Value, i, j int) bool {
sort.go#L82: return ss.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
sort.go#L111: fnc reflect.Value // func(T, T) bool
sort.go#L137: func (ms mapSorter) checkSort(v reflect.Value) {
sort.go#L144: func (ms mapSorter) less(v reflect.Value, i, j int) bool {
sort.go#L146: return ms.fnc.Call([]reflect.Value{vx, vy})[0].Bool()
github.com/google/go-cmp/cmp/internal/function
func.go#L71: func NameOf(v reflect.Value) string {
github.com/google/go-cmp/cmp/internal/value
pointer_unsafe.go#L22: func PointerOf(v reflect.Value) Pointer {
sort.go#L16: func SortKeys(vs []reflect.Value) []reflect.Value {
sort.go#L36: func isLess(x, y reflect.Value) bool {
zero.go#L14: func IsZero(v reflect.Value) bool {
github.com/imdario/mergo
map.go#L34: func deepMap(dst, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (err error) {
map.go#L49: zeroValue := reflect.Value{}
map.go#L145: vDst, vSrc reflect.Value
merge.go#L17: func hasExportedField(dst reflect.Value) (exported bool) {
merge.go#L50: Transformer(reflect.Type) func(dst, src reflect.Value) error
merge.go#L56: func deepMerge(dstIn, src reflect.Value, visited map[uintptr]*visit, depth int, config *Config) (dst reflect.Value, err error) {
merge.go#L304: vDst, vSrc reflect.Value
merge.go#L328: func isReflectNil(v reflect.Value) bool {
mergo.go#L36: func isEmptyValue(v reflect.Value) bool {
mergo.go#L61: func resolveValues(dst, src interface{}) (vDst, vSrc reflect.Value, err error) {
mergo.go#L82: func deeper(dst, src reflect.Value, visited map[uintptr]*visit, depth int) (err error) {
github.com/jackc/pgtype
aclitem_array.go#L144: func (dst *ACLItemArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
aclitem_array.go#L259: func (src *ACLItemArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
array.go#L362: func findDimensionsFromValue(value reflect.Value, dimensions []ArrayDimension, elementsLength int) ([]ArrayDimension, int, bool) {
bool_array.go#L147: func (dst *BoolArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
bool_array.go#L262: func (src *BoolArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
bpchar_array.go#L147: func (dst *BPCharArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
bpchar_array.go#L262: func (src *BPCharArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
bytea_array.go#L128: func (dst *ByteaArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
bytea_array.go#L234: func (src *ByteaArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
cidr_array.go#L167: func (dst *CIDRArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
cidr_array.go#L291: func (src *CIDRArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
date_array.go#L148: func (dst *DateArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
date_array.go#L263: func (src *DateArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
enum_array.go#L144: func (dst *EnumArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
enum_array.go#L259: func (src *EnumArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
float4_array.go#L147: func (dst *Float4Array) setRecursive(value reflect.Value, index, dimension int) (int, error) {
float4_array.go#L262: func (src *Float4Array) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
float8_array.go#L147: func (dst *Float8Array) setRecursive(value reflect.Value, index, dimension int) (int, error) {
float8_array.go#L262: func (src *Float8Array) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
hstore_array.go#L128: func (dst *HstoreArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
hstore_array.go#L234: func (src *HstoreArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
inet_array.go#L167: func (dst *InetArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
inet_array.go#L291: func (src *InetArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
int2_array.go#L413: func (dst *Int2Array) setRecursive(value reflect.Value, index, dimension int) (int, error) {
int2_array.go#L654: func (src *Int2Array) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
int4_array.go#L413: func (dst *Int4Array) setRecursive(value reflect.Value, index, dimension int) (int, error) {
int4_array.go#L654: func (src *Int4Array) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
int8_array.go#L413: func (dst *Int8Array) setRecursive(value reflect.Value, index, dimension int) (int, error) {
int8_array.go#L654: func (src *Int8Array) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
jsonb_array.go#L147: func (dst *JSONBArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
jsonb_array.go#L262: func (src *JSONBArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
macaddr_array.go#L148: func (dst *MacaddrArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
macaddr_array.go#L263: func (src *MacaddrArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
numeric_array.go#L261: func (dst *NumericArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
numeric_array.go#L430: func (src *NumericArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
text_array.go#L147: func (dst *TextArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
text_array.go#L262: func (src *TextArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
timestamp_array.go#L148: func (dst *TimestampArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
timestamp_array.go#L263: func (src *TimestampArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
timestamptz_array.go#L148: func (dst *TimestamptzArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
timestamptz_array.go#L263: func (src *TimestamptzArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
tsrange_array.go#L109: func (dst *TsrangeArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
tsrange_array.go#L215: func (src *TsrangeArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
tstzrange_array.go#L109: func (dst *TstzrangeArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
tstzrange_array.go#L215: func (src *TstzrangeArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
uuid_array.go#L185: func (dst *UUIDArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
uuid_array.go#L318: func (src *UUIDArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
varchar_array.go#L147: func (dst *VarcharArray) setRecursive(value reflect.Value, index, dimension int) (int, error) {
varchar_array.go#L262: func (src *VarcharArray) assignToRecursive(value reflect.Value, index, dimension int) (int, error) {
github.com/jackc/pgx/v4
values.go#L240: func stripNamedType(val *reflect.Value) (interface{}, bool) {
github.com/lann/builder
builder.go#L89: func listToSlice(list ps.List, arrayType reflect.Type) reflect.Value {
builder.go#L202: func scanStruct(builder interface{}, structVal *reflect.Value) interface{} {
builder.go#L207: var value reflect.Value
registry.go#L21: func RegisterType(builderType reflect.Type, structType reflect.Type) *reflect.Value {
registry.go#L52: func newBuilderStruct(builderType reflect.Type) *reflect.Value {
github.com/lib/pq
array.go#L274: func (GenericArray) evaluateDestination(rt reflect.Type) (reflect.Type, func([]byte, reflect.Value) error, string) {
array.go#L275: var assign func([]byte, reflect.Value) error
array.go#L283: assign = func(src []byte, dest reflect.Value) (err error) {
array.go#L295: assign = func([]byte, reflect.Value) error {
array.go#L342: func (a GenericArray) scanBytes(src []byte, dv reflect.Value) error {
array.go#L551: func appendArray(b []byte, rv reflect.Value, n int) ([]byte, string, error) {
array.go#L579: func appendArrayElement(b []byte, rv reflect.Value) ([]byte, string, error) {
go.opentelemetry.io/otel/label
set.go#L86: func (d Distinct) reflect() reflect.Value {
go/ast
print.go#L18: type FieldFilter func(name string, value reflect.Value) bool
print.go#L22: func NotNilFilter(_ string, v reflect.Value) bool {
print.go#L143: func (p *printer) print(x reflect.Value) {
golang.org/x/pkgsite/internal/database
reflect.go#L102: ptr reflect.Value
google.golang.org/api/internal/gensupport
json.go#L123: func formatAsString(v reflect.Value, kind reflect.Kind) string {
json.go#L170: func includeField(v reflect.Value, f reflect.StructField, mustInclude map[string]bool) bool {
json.go#L195: func isEmptyValue(v reflect.Value) bool {
google.golang.org/api/support/bundler
bundler.go#L85: itemSliceZero reflect.Value // nil (zero value) for slice of items
bundler.go#L119: items reflect.Value // slice of T
google.golang.org/protobuf/internal/descfmt
stringer.go#L92: v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
stringer.go#L205: func (rs *records) Append(v reflect.Value, accessors ...string) {
stringer.go#L207: var rv reflect.Value
google.golang.org/protobuf/internal/impl
codec_field.go#L55: var vw reflect.Value // pointer to wrapper type
codec_field.go#L823: func asMessage(v reflect.Value) pref.ProtoMessage {
codec_map.go#L92: func sizeMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) int {
codec_map.go#L115: func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L172: func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L236: func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L267: func appendMap(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L286: func appendMapDeterministic(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L315: func isInitMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo) error {
codec_map_go112.go#L11: func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() }
convert.go#L23: PBValueOf(reflect.Value) pref.Value
convert.go#L26: GoValueOf(pref.Value) reflect.Value
convert.go#L32: IsValidGo(reflect.Value) bool
convert.go#L151: func (c *boolConverter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L157: func (c *boolConverter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L164: func (c *boolConverter) IsValidGo(v reflect.Value) bool {
convert.go#L175: func (c *int32Converter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L181: func (c *int32Converter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L188: func (c *int32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L199: func (c *int64Converter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L205: func (c *int64Converter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L212: func (c *int64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L223: func (c *uint32Converter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L229: func (c *uint32Converter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L236: func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L247: func (c *uint64Converter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L253: func (c *uint64Converter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L260: func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L271: func (c *float32Converter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L277: func (c *float32Converter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L284: func (c *float32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L295: func (c *float64Converter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L301: func (c *float64Converter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L308: func (c *float64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L319: func (c *stringConverter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L325: func (c *stringConverter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L338: func (c *stringConverter) IsValidGo(v reflect.Value) bool {
convert.go#L349: func (c *bytesConverter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L358: func (c *bytesConverter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L365: func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
convert.go#L386: func (c *enumConverter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L393: func (c *enumConverter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L402: func (c *enumConverter) IsValidGo(v reflect.Value) bool {
convert.go#L422: func (c *messageConverter) PBValueOf(v reflect.Value) pref.Value {
convert.go#L432: func (c *messageConverter) GoValueOf(v pref.Value) reflect.Value {
convert.go#L434: var rv reflect.Value
convert.go#L448: var rv reflect.Value
convert.go#L457: func (c *messageConverter) IsValidGo(v reflect.Value) bool {
convert_list.go#L29: func (c *listConverter) PBValueOf(v reflect.Value) pref.Value {
convert_list.go#L38: func (c *listConverter) GoValueOf(v pref.Value) reflect.Value {
convert_list.go#L54: func (c *listConverter) IsValidGo(v reflect.Value) bool {
convert_list.go#L71: func (c *listPtrConverter) PBValueOf(v reflect.Value) pref.Value {
convert_list.go#L78: func (c *listPtrConverter) GoValueOf(v pref.Value) reflect.Value {
convert_list.go#L90: func (c *listPtrConverter) IsValidGo(v reflect.Value) bool {
convert_list.go#L103: v reflect.Value // *[]T
convert_map.go#L30: func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value {
convert_map.go#L37: func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
convert_map.go#L49: func (c *mapConverter) IsValidGo(v reflect.Value) bool {
convert_map.go#L62: v reflect.Value // map[K]V
convert_map.go#L90: ms.v.SetMapIndex(rk, reflect.Value{})
legacy_enum.go#L37: func legacyWrapEnum(v reflect.Value) pref.Enum {
legacy_message.go#L26: func legacyWrapMessage(v reflect.Value) pref.Message {
legacy_message.go#L200: for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
legacy_message.go#L212: vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
legacy_message.go#L443: v reflect.Value
message.go#L186: for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
pointer_unsafe.go#L47: func pointerOfValue(v reflect.Value) pointer {
pointer_unsafe.go#L76: func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
gopkg.in/yaml.v2
decode.go#L253: func (d *decoder) terror(n *node, tag string, out reflect.Value) {
decode.go#L297: func (d *decoder) prepare(n *node, out reflect.Value) (newout reflect.Value, unmarshaled, good bool) {
decode.go#L350: func (d *decoder) unmarshal(n *node, out reflect.Value) (good bool) {
decode.go#L381: func (d *decoder) document(n *node, out reflect.Value) (good bool) {
decode.go#L390: func (d *decoder) alias(n *node, out reflect.Value) (good bool) {
decode.go#L403: var zeroValue reflect.Value
decode.go#L405: func resetMap(out reflect.Value) {
decode.go#L411: func (d *decoder) scalar(n *node, out reflect.Value) bool {
decode.go#L578: func settableValueOf(i interface{}) reflect.Value {
decode.go#L585: func (d *decoder) sequence(n *node, out reflect.Value) (good bool) {
decode.go#L588: var iface reflect.Value
decode.go#L623: func (d *decoder) mapping(n *node, out reflect.Value) (good bool) {
decode.go#L685: func (d *decoder) setMapIndex(n *node, out, k, v reflect.Value) {
decode.go#L693: func (d *decoder) mappingSlice(n *node, out reflect.Value) (good bool) {
decode.go#L724: func (d *decoder) mappingStruct(n *node, out reflect.Value) (good bool) {
decode.go#L732: var inlineMap reflect.Value
decode.go#L761: var field reflect.Value
decode.go#L786: func (d *decoder) merge(n *node, out reflect.Value) {
encode.go#L89: func (e *encoder) marshalDoc(tag string, in reflect.Value) {
encode.go#L98: func (e *encoder) marshal(tag string, in reflect.Value) {
encode.go#L187: func (e *encoder) mapv(tag string, in reflect.Value) {
encode.go#L198: func (e *encoder) itemsv(tag string, in reflect.Value) {
encode.go#L208: func (e *encoder) structv(tag string, in reflect.Value) {
encode.go#L215: var value reflect.Value
encode.go#L261: func (e *encoder) slicev(tag string, in reflect.Value) {
encode.go#L300: func (e *encoder) stringv(tag string, in reflect.Value) {
encode.go#L337: func (e *encoder) boolv(tag string, in reflect.Value) {
encode.go#L347: func (e *encoder) intv(tag string, in reflect.Value) {
encode.go#L352: func (e *encoder) uintv(tag string, in reflect.Value) {
encode.go#L357: func (e *encoder) timev(tag string, in reflect.Value) {
encode.go#L363: func (e *encoder) floatv(tag string, in reflect.Value) {
sorter.go#L8: type keyList []reflect.Value
sorter.go#L82: func keyFloat(v reflect.Value) (f float64, ok bool) {
sorter.go#L101: func numLess(a, b reflect.Value) bool {
yaml.go#L428: func isZero(v reflect.Value) bool {
internal/fmtsort
sort.go#L22: Key []reflect.Value
sort.go#L23: Value []reflect.Value
sort.go#L52: func Sort(mapValue reflect.Value) *SortedMap {
sort.go#L60: key := make([]reflect.Value, 0, n)
sort.go#L61: value := make([]reflect.Value, 0, n)
sort.go#L79: func compare(aVal, bVal reflect.Value) int {
sort.go#L190: func nilCompare(aVal, bVal reflect.Value) (int, bool) {
net/http/httptrace
trace.go#L202: newFunc := reflect.MakeFunc(hookType, func(args []reflect.Value) []reflect.Value {
text/template
exec.go#L44: value reflect.Value
exec.go#L48: func (s *state) push(name string, value reflect.Value) {
exec.go#L64: func (s *state) setVar(name string, value reflect.Value) {
exec.go#L75: func (s *state) setTopVar(n int, value reflect.Value) {
exec.go#L80: func (s *state) varValue(name string) reflect.Value {
exec.go#L90: var zero reflect.Value
exec.go#L208: value, ok := data.(reflect.Value)
exec.go#L249: func (s *state) walk(dot reflect.Value, node parse.Node) {
exec.go#L283: func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
exec.go#L308: func isTrue(val reflect.Value) (truth, ok bool) {
exec.go#L336: func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
exec.go#L342: oneIteration := func(index, elem reflect.Value) {
exec.go#L402: func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
exec.go#L429: func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
exec.go#L452: func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
exec.go#L458: func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
exec.go#L497: func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
exec.go#L532: func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L537: func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L550: func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L564: func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L573: func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L586: func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value {
exec.go#L667: reflectValueType = reflect.TypeOf((*reflect.Value)(nil)).Elem()
exec.go#L673: func (s *state) evalCall(dot, fun reflect.Value, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L696: argv := make([]reflect.Value, numIn)
exec.go#L733: v = v.Interface().(reflect.Value)
exec.go#L750: func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
exec.go#L792: func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L839: func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L850: func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L861: func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L872: func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L883: func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L894: func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L904: func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
exec.go#L934: func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
exec.go#L947: func indirectInterface(v reflect.Value) reflect.Value {
exec.go#L952: return reflect.Value{}
exec.go#L959: func (s *state) printValue(n parse.Node, v reflect.Value) {
exec.go#L973: func printableValue(v reflect.Value) (interface{}, bool) {
funcs.go#L65: v map[string]reflect.Value
funcs.go#L70: func builtinFuncs() map[string]reflect.Value {
funcs.go#L78: func createValueFuncs(funcMap FuncMap) map[string]reflect.Value {
funcs.go#L79: m := make(map[string]reflect.Value)
funcs.go#L85: func addValueFuncs(out map[string]reflect.Value, in FuncMap) {
funcs.go#L139: func findFunction(name string, tmpl *Template) (reflect.Value, bool) {
funcs.go#L150: return reflect.Value{}, false
funcs.go#L155: func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
funcs.go#L158: return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
funcs.go#L169: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L183: func indexArg(index reflect.Value, cap int) (int, error) {
funcs.go#L206: func index(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
funcs.go#L209: return reflect.Value{}, fmt.Errorf("index of untyped nil")
funcs.go#L215: return reflect.Value{}, fmt.Errorf("index of nil pointer")
funcs.go#L221: return reflect.Value{}, err
funcs.go#L227: return reflect.Value{}, err
funcs.go#L238: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L250: func slice(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
funcs.go#L253: return reflect.Value{}, fmt.Errorf("slice of untyped nil")
funcs.go#L256: return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
funcs.go#L262: return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
funcs.go#L268: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L275: return reflect.Value{}, err
funcs.go#L281: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
funcs.go#L288: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
funcs.go#L296: func length(item reflect.Value) (int, error) {
funcs.go#L312: func call(fn reflect.Value, args ...reflect.Value) (reflect.Value, error) {
funcs.go#L315: return reflect.Value{}, fmt.Errorf("call of nil")
funcs.go#L319: return reflect.Value{}, fmt.Errorf("non-function of type %s", typ)
funcs.go#L322: return reflect.Value{}, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut())
funcs.go#L328: return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1)
funcs.go#L333: return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn)
funcs.go#L336: argv := make([]reflect.Value, len(args))
funcs.go#L347: return reflect.Value{}, fmt.Errorf("arg %d: %s", i, err)
funcs.go#L355: func safeCall(fun reflect.Value, args []reflect.Value) (val reflect.Value, err error) {
funcs.go#L374: func truth(arg reflect.Value) bool {
funcs.go#L381: func and(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
funcs.go#L396: func or(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
funcs.go#L410: func not(arg reflect.Value) bool {
funcs.go#L436: func basicKind(v reflect.Value) (kind, error) {
funcs.go#L455: func eq(arg1 reflect.Value, arg2 ...reflect.Value) (bool, error) {
funcs.go#L513: func ne(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L520: func lt(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L562: func le(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L572: func gt(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L582: func ge(arg1, arg2 reflect.Value) (bool, error) {
template.go#L22: execFuncs map[string]reflect.Value
template.go#L74: c.execFuncs = make(map[string]reflect.Value)
 |
The pages are generated with Golds v0.3.2-preview. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |