type reflect.Value
953 uses
reflect (current package)
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 {
makefunc.go#L22: fn func([]Value) []Value
makefunc.go#L47: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
makefunc.go#L71: return Value{t, unsafe.Pointer(impl), flag(Func)}
makefunc.go#L87: rcvr Value
makefunc.go#L97: func makeMethodValue(op string, v Value) Value {
makefunc.go#L105: rcvr := Value{v.typ, v.ptr, fl}
makefunc.go#L130: return Value{&ftyp.rtype, unsafe.Pointer(fv), v.flag&flagRO | flag(Func)}
type.go#L618: Func Value // func with receiver as first argument
type.go#L873: m.Func = Value{mt.(*rtype), fn, fl}
type.go#L2499: ifn Value
type.go#L2500: tfn Value
type.go#L2504: tfn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2505: var args []Value
type.go#L2512: ifn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2513: var args []Value
type.go#L2521: tfn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2522: var args []Value
type.go#L2529: ifn = MakeFunc(mtyp, func(in []Value) []Value {
type.go#L2530: var args []Value
value.go#L39: type Value struct {
value.go#L96: func (v Value) pointer() unsafe.Pointer {
value.go#L107: func packEface(v Value) any {
value.go#L144: func unpackEface(i any) Value {
value.go#L149: return Value{}
value.go#L155: return Value{t, e.word, f}
value.go#L271: func (v Value) Addr() Value {
value.go#L278: return Value{v.typ.ptrTo(), v.ptr, fl | flag(Pointer)}
value.go#L283: func (v Value) Bool() bool {
value.go#L290: func (v Value) Bytes() []byte {
value.go#L301: func (v Value) runes() []rune {
value.go#L315: func (v Value) CanAddr() bool {
value.go#L324: func (v Value) CanSet() bool {
value.go#L336: func (v Value) Call(in []Value) []Value {
value.go#L349: func (v Value) CallSlice(in []Value) []Value {
value.go#L359: func (v Value) call(op string, in []Value) []Value {
value.go#L364: rcvr Value
value.go#L427: in = make([]Value, n+1)
value.go#L563: var ret []Value
value.go#L578: ret = make([]Value, nout)
value.go#L593: ret[i] = Value{tv.common(), add(stackArgs, st.stkOff, "tv.Size() != 0"), fl}
value.go#L609: ret[i] = Value{tv.common(), regArgs.Ptrs[steps[0].ireg], flag(tv.Kind())}
value.go#L640: ret[i] = Value{tv.common(), s, flagIndir | flag(tv.Kind())}
value.go#L683: in := make([]Value, 0, int(ftyp.inCount))
value.go#L689: v := Value{typ, nil, flag(typ.Kind())}
value.go#L847: func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer) {
value.go#L886: func storeRcvr(v Value, p unsafe.Pointer) {
value.go#L1106: func funcName(f func([]Value) []Value) string {
value.go#L1117: func (v Value) Cap() int {
value.go#L1133: func (v Value) Close() {
value.go#L1140: func (v Value) CanComplex() bool {
value.go#L1151: func (v Value) Complex() complex128 {
value.go#L1166: func (v Value) Elem() Value {
value.go#L1205: return Value{}
value.go#L1211: return Value{typ, ptr, fl}
value.go#L1218: func (v Value) Field(i int) Value {
value.go#L1245: return Value{typ, ptr, fl}
value.go#L1251: func (v Value) FieldByIndex(index []int) Value {
value.go#L1274: func (v Value) FieldByIndexErr(index []int) (Value, error) {
value.go#L1283: return Value{}, errors.New("reflect: indirection through nil pointer to embedded struct field " + v.typ.Elem().Name())
value.go#L1296: func (v Value) FieldByName(name string) Value {
value.go#L1301: return Value{}
value.go#L1308: func (v Value) FieldByNameFunc(match func(string) bool) Value {
value.go#L1312: return Value{}
value.go#L1316: func (v Value) CanFloat() bool {
value.go#L1327: func (v Value) Float() float64 {
value.go#L1342: func (v Value) Index(i int) Value {
value.go#L1359: return Value{typ, val, fl}
value.go#L1372: return Value{typ, val, fl}
value.go#L1381: return Value{uint8Type, p, fl}
value.go#L1387: func (v Value) CanInt() bool {
value.go#L1398: func (v Value) Int() int64 {
value.go#L1417: func (v Value) CanInterface() bool {
value.go#L1429: func (v Value) Interface() (i any) {
value.go#L1433: func valueInterface(v Value, safe bool) any {
value.go#L1472: func (v Value) InterfaceData() [2]uintptr {
value.go#L1489: func (v Value) IsNil() bool {
value.go#L1514: func (v Value) IsValid() bool {
value.go#L1520: func (v Value) IsZero() bool {
value.go#L1560: func (v Value) Kind() Kind {
value.go#L1566: func (v Value) Len() int {
value.go#L1592: func (v Value) MapIndex(key Value) Value {
value.go#L1619: return Value{}
value.go#L1631: func (v Value) MapKeys() []Value {
value.go#L1645: a := make([]Value, mlen)
value.go#L1690: m Value
value.go#L1695: func (iter *MapIter) Key() Value {
value.go#L1712: func (v Value) SetIterKey(iter *MapIter) {
value.go#L1730: key := Value{ktype, iterkey, iter.m.flag | flag(ktype.Kind()) | flagIndir}
value.go#L1736: func (iter *MapIter) Value() Value {
value.go#L1753: func (v Value) SetIterValue(iter *MapIter) {
value.go#L1771: elem := Value{vtype, iterelem, iter.m.flag | flag(vtype.Kind()) | flagIndir}
value.go#L1798: func (iter *MapIter) Reset(v Value) {
value.go#L1822: func (v Value) MapRange() *MapIter {
value.go#L1829: func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value {
value.go#L1835: return Value{typ, c, fl | flagIndir}
value.go#L1837: return Value{typ, *(*unsafe.Pointer)(ptr), fl}
value.go#L1844: func (v Value) Method(i int) Value {
value.go#L1857: return Value{v.typ, v.ptr, fl}
value.go#L1861: func (v Value) NumMethod() int {
value.go#L1876: func (v Value) MethodByName(name string) Value {
value.go#L1881: return Value{}
value.go#L1885: return Value{}
value.go#L1892: func (v Value) NumField() int {
value.go#L1900: func (v Value) OverflowComplex(x complex128) bool {
value.go#L1913: func (v Value) OverflowFloat(x float64) bool {
value.go#L1933: func (v Value) OverflowInt(x int64) bool {
value.go#L1946: func (v Value) OverflowUint(x uint64) bool {
value.go#L1978: func (v Value) Pointer() uintptr {
value.go#L2023: func (v Value) Recv() (x Value, ok bool) {
value.go#L2031: func (v Value) recv(nb bool) (val Value, ok bool) {
value.go#L2037: val = Value{t, nil, flag(t.Kind())}
value.go#L2048: val = Value{}
value.go#L2056: func (v Value) Send(x Value) {
value.go#L2064: func (v Value) send(x Value, nb bool) (selected bool) {
value.go#L2083: func (v Value) Set(x Value) {
value.go#L2104: func (v Value) SetBool(x bool) {
value.go#L2112: func (v Value) SetBytes(x []byte) {
value.go#L2123: func (v Value) setRunes(x []rune) {
value.go#L2134: func (v Value) SetComplex(x complex128) {
value.go#L2148: func (v Value) SetFloat(x float64) {
value.go#L2162: func (v Value) SetInt(x int64) {
value.go#L2183: func (v Value) SetLen(n int) {
value.go#L2196: func (v Value) SetCap(n int) {
value.go#L2212: func (v Value) SetMapIndex(key, elem Value) {
value.go#L2260: func (v Value) SetUint(x uint64) {
value.go#L2282: func (v Value) SetPointer(x unsafe.Pointer) {
value.go#L2290: func (v Value) SetString(x string) {
value.go#L2299: func (v Value) Slice(i, j int) Value {
value.go#L2333: return Value{v.typ, unsafe.Pointer(&t), v.flag}
value.go#L2355: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L2361: func (v Value) Slice3(i, j, k int) Value {
value.go#L2407: return Value{typ.common(), unsafe.Pointer(&x), fl}
value.go#L2416: func (v Value) String() string {
value.go#L2433: func (v Value) TryRecv() (x Value, ok bool) {
value.go#L2443: func (v Value) TrySend(x Value) bool {
value.go#L2450: func (v Value) Type() Type {
value.go#L2482: func (v Value) CanUint() bool {
value.go#L2493: func (v Value) Uint() uint64 {
value.go#L2523: func (v Value) UnsafeAddr() uintptr {
value.go#L2544: func (v Value) UnsafePointer() unsafe.Pointer {
value.go#L2626: func grow(s Value, extra int) (Value, int, int) {
value.go#L2655: func Append(s Value, x ...Value) Value {
value.go#L2666: func AppendSlice(s, t Value) Value {
value.go#L2682: func Copy(dst, src Value) int {
value.go#L2779: Chan Value // channel to use (for send or receive)
value.go#L2780: Send Value // value to send (for send)
value.go#L2791: func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool) {
value.go#L2879: recv = Value{t, p, fl | flagIndir}
value.go#L2881: recv = Value{t, *(*unsafe.Pointer)(p), fl}
value.go#L2897: func MakeSlice(typ Type, len, cap int) Value {
value.go#L2912: return Value{typ.(*rtype), unsafe.Pointer(&s), flagIndir | flag(Slice)}
value.go#L2916: func MakeChan(typ Type, buffer int) Value {
value.go#L2928: return Value{t, ch, flag(Chan)}
value.go#L2932: func MakeMap(typ Type) Value {
value.go#L2938: func MakeMapWithSize(typ Type, n int) Value {
value.go#L2944: return Value{t, m, flag(Map)}
value.go#L2950: func Indirect(v Value) Value {
value.go#L2959: func ValueOf(i any) Value {
value.go#L2961: return Value{}
value.go#L2978: func Zero(typ Type) Value {
value.go#L2991: return Value{t, p, fl | flagIndir}
value.go#L2993: return Value{t, nil, fl}
value.go#L3004: func New(typ Type) Value {
value.go#L3016: return Value{pt, ptr, fl}
value.go#L3021: func NewAt(typ Type, p unsafe.Pointer) Value {
value.go#L3024: return Value{t.ptrTo(), p, fl}
value.go#L3031: func (v Value) assignTo(context string, dst *rtype, target unsafe.Pointer) Value {
value.go#L3042: return Value{dst, v.ptr, fl}
value.go#L3052: return Value{dst, nil, flag(Interface)}
value.go#L3060: return Value{dst, target, flagIndir | flag(Interface)}
value.go#L3070: func (v Value) Convert(t Type) Value {
value.go#L3083: func (v Value) CanConvert(t Type) bool {
value.go#L3102: func convertOp(dst, src *rtype) func(Value, Type) Value {
value.go#L3195: func makeInt(f flag, bits uint64, t Type) Value {
value.go#L3208: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3213: func makeFloat(f flag, v float64, t Type) Value {
value.go#L3222: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3226: func makeFloat32(f flag, v float32, t Type) Value {
value.go#L3230: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3235: func makeComplex(f flag, v complex128, t Type) Value {
value.go#L3244: return Value{typ, ptr, f | flagIndir | flag(typ.Kind())}
value.go#L3247: func makeString(f flag, v string, t Type) Value {
value.go#L3254: func makeBytes(f flag, v []byte, t Type) Value {
value.go#L3261: func makeRunes(f flag, v []rune, t Type) Value {
value.go#L3274: func cvtInt(v Value, t Type) Value {
value.go#L3279: func cvtUint(v Value, t Type) Value {
value.go#L3284: func cvtFloatInt(v Value, t Type) Value {
value.go#L3289: func cvtFloatUint(v Value, t Type) Value {
value.go#L3294: func cvtIntFloat(v Value, t Type) Value {
value.go#L3299: func cvtUintFloat(v Value, t Type) Value {
value.go#L3304: func cvtFloat(v Value, t Type) Value {
value.go#L3315: func cvtComplex(v Value, t Type) Value {
value.go#L3320: func cvtIntString(v Value, t Type) Value {
value.go#L3329: func cvtUintString(v Value, t Type) Value {
value.go#L3338: func cvtBytesString(v Value, t Type) Value {
value.go#L3343: func cvtStringBytes(v Value, t Type) Value {
value.go#L3348: func cvtRunesString(v Value, t Type) Value {
value.go#L3353: func cvtStringRunes(v Value, t Type) Value {
value.go#L3358: func cvtSliceArrayPtr(v Value, t Type) Value {
value.go#L3364: return Value{t.common(), h.Data, v.flag&^(flagIndir|flagAddr|flagKindMask) | flag(Pointer)}
value.go#L3368: func cvtDirect(v Value, typ Type) Value {
value.go#L3379: return Value{t, ptr, v.flag.ro() | f} // v.flag.ro()|f == f?
value.go#L3383: func cvtT2I(v Value, typ Type) Value {
value.go#L3391: return Value{typ.common(), target, v.flag.ro() | flagIndir | flag(Interface)}
value.go#L3395: func cvtI2I(v Value, typ Type) 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/json
decode.go#L356: func (d *decodeState) value(v reflect.Value) error {
decode.go#L425: func indirect(v reflect.Value, decodingNull bool) (Unmarshaler, encoding.TextUnmarshaler, reflect.Value) {
decode.go#L479: return u, nil, reflect.Value{}
decode.go#L483: return nil, u, reflect.Value{}
decode.go#L500: func (d *decodeState) array(v reflect.Value) error {
decode.go#L566: if err := d.value(reflect.Value{}); err != nil {
decode.go#L606: func (d *decodeState) object(v reflect.Value) error {
decode.go#L662: var mapElem reflect.Value
decode.go#L689: var subv reflect.Value
decode.go#L731: subv = reflect.Value{}
decode.go#L783: var kv reflect.Value
decode.go#L861: 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#L834: func encodeByteSlice(e *encodeState, v reflect.Value, _ encOpts) {
encode.go#L869: func (se sliceEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L909: func (ae arrayEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L930: func (pe ptrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L958: func (ce condAddrEncoder) encode(e *encodeState, v reflect.Value, opts encOpts) {
encode.go#L1001: k reflect.Value
encode.go#L1002: v reflect.Value
encoding/xml
marshal.go#L408: func (p *printer) marshalValue(val reflect.Value, finfo *fieldInfo, startTemplate *StartElement) error {
marshal.go#L557: func (p *printer) marshalAttr(start *StartElement, name Name, val reflect.Value) error {
marshal.go#L758: func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
marshal.go#L799: func indirect(vf reflect.Value) reflect.Value {
marshal.go#L809: func (p *printer) marshalStruct(tinfo *typeInfo, val reflect.Value) error {
marshal.go#L1046: 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/go-pg/pg/v10/internal
util.go#L21: func MakeSliceNextElemFunc(v reflect.Value) func() reflect.Value {
util.go#L24: return func() reflect.Value {
util.go#L35: return func() reflect.Value {
util.go#L52: return func() reflect.Value {
github.com/go-pg/pg/v10/orm
composite.go#L17: return func(v reflect.Value, rd types.Reader, n int) error {
composite.go#L82: return func(b []byte, v reflect.Value, quote int) []byte {
delete.go#L116: fmter QueryFormatter, b []byte, slice reflect.Value, alias types.Safe, fields []*Field,
field.go#L69: func (f *Field) Value(strct reflect.Value) reflect.Value {
field.go#L73: func (f *Field) HasZeroValue(strct reflect.Value) bool {
field.go#L77: func (f *Field) hasZeroValue(v reflect.Value, index []int) bool {
field.go#L94: func (f *Field) AppendValue(b []byte, strct reflect.Value, quote int) []byte {
field.go#L109: func (f *Field) ScanValue(strct reflect.Value, rd types.Reader, n int) error {
field.go#L114: var fv reflect.Value
field.go#L133: appender func([]byte, reflect.Value, int) []byte
field.go#L140: func (m *Method) Value(strct reflect.Value) reflect.Value {
field.go#L144: func (m *Method) AppendValue(dst []byte, strct reflect.Value, quote int) []byte {
hook.go#L55: slice reflect.Value,
hook.go#L57: hook func(context.Context, reflect.Value) (context.Context, error),
hook.go#L78: slice reflect.Value,
hook.go#L80: hook func(context.Context, reflect.Value) error,
hook.go#L108: func callBeforeScanHook(ctx context.Context, v reflect.Value) error {
hook.go#L120: func callAfterScanHook(ctx context.Context, v reflect.Value) error {
hook.go#L132: func callAfterSelectHook(ctx context.Context, v reflect.Value) error {
hook.go#L137: ctx context.Context, slice reflect.Value, ptr bool,
hook.go#L150: func callBeforeInsertHook(ctx context.Context, v reflect.Value) (context.Context, error) {
hook.go#L155: ctx context.Context, slice reflect.Value, ptr bool,
hook.go#L168: func callAfterInsertHook(ctx context.Context, v reflect.Value) error {
hook.go#L173: ctx context.Context, slice reflect.Value, ptr bool,
hook.go#L186: func callBeforeUpdateHook(ctx context.Context, v reflect.Value) (context.Context, error) {
hook.go#L191: ctx context.Context, slice reflect.Value, ptr bool,
hook.go#L204: func callAfterUpdateHook(ctx context.Context, v reflect.Value) error {
hook.go#L209: ctx context.Context, slice reflect.Value, ptr bool,
hook.go#L222: func callBeforeDeleteHook(ctx context.Context, v reflect.Value) (context.Context, error) {
hook.go#L227: ctx context.Context, slice reflect.Value, ptr bool,
hook.go#L240: func callAfterDeleteHook(ctx context.Context, v reflect.Value) error {
hook.go#L245: ctx context.Context, slice reflect.Value, ptr bool,
insert.go#L230: fmter QueryFormatter, b []byte, fields []*Field, strct reflect.Value,
insert.go#L273: fmter QueryFormatter, b []byte, fields []*Field, slice reflect.Value,
insert.go#L276: return q.appendValues(fmter, b, fields, reflect.Value{})
join.go#L322: func appendChildValues(b []byte, v reflect.Value, index []int, fields []*Field) []byte {
join.go#L324: walk(v, index, func(v reflect.Value) {
model_func.go#L12: fnv reflect.Value
model_func.go#L13: fnIn []reflect.Value
model_func.go#L46: var v0 reflect.Value
model_func.go#L54: m.fnIn = []reflect.Value{v0}
model_func.go#L75: m.fnIn = make([]reflect.Value, fnt.NumIn())
model_scan.go#L44: values []reflect.Value
model_scan.go#L49: func scanReflectValues(values []reflect.Value) scanReflectValuesModel {
model_slice.go#L12: slice reflect.Value
model_slice.go#L13: nextElem func() reflect.Value
model_slice.go#L14: scan func(reflect.Value, types.Reader, int) error
model_slice.go#L19: func newSliceModel(slice reflect.Value, elemType reflect.Type) *sliceModel {
model_table.go#L23: Root() reflect.Value
model_table.go#L26: Mount(reflect.Value)
model_table.go#L28: Value() reflect.Value
model_table.go#L34: func newTableModelIndex(typ reflect.Type, root reflect.Value, index []int, rel *Relation) (TableModel, error) {
model_table_m2m.go#L17: dstValues map[string][]reflect.Value
model_table_many.go#L14: dstValues map[string][]reflect.Value
model_table_slice.go#L13: slice reflect.Value
model_table_slice.go#L16: nextElem func() reflect.Value
model_table_slice.go#L21: func newSliceTableModel(slice reflect.Value, elemType reflect.Type) *sliceTableModel {
model_table_slice.go#L62: func (m *sliceTableModel) Bind(bind reflect.Value) {
model_table_slice.go#L70: func (m *sliceTableModel) Value() reflect.Value {
model_table_struct.go#L17: root reflect.Value
model_table_struct.go#L20: strct reflect.Value
model_table_struct.go#L33: func newStructTableModelValue(v reflect.Value) *structTableModel {
model_table_struct.go#L91: func (m *structTableModel) Root() reflect.Value {
model_table_struct.go#L107: func (m *structTableModel) Value() reflect.Value {
model_table_struct.go#L111: func (m *structTableModel) Mount(host reflect.Value) {
model_table_struct.go#L325: bind reflect.Value, name string, apply func(*Query) (*Query, error),
msgpack.go#L12: return func(b []byte, v reflect.Value, flags int) []byte {
msgpack.go#L32: return func(v reflect.Value, rd types.Reader, n int) error {
query.go#L1581: fmter QueryFormatter, b []byte, v reflect.Value, alias types.Safe, fields []*Field,
table.go#L63: zeroStruct reflect.Value
table.go#L90: SetSoftDeleteField func(fv reflect.Value) error
table.go#L234: func (t *Table) AppendParam(b []byte, strct reflect.Value, name string) ([]byte, bool) {
table.go#L1424: func scanJSONValue(v reflect.Value, rd types.Reader, n int) error {
table.go#L1438: func appendUintAsInt(b []byte, v reflect.Value, _ int) []byte {
table.go#L1442: func appendUintPtrAsInt(b []byte, v reflect.Value, _ int) []byte {
table.go#L1469: func setSoftDeleteFieldFunc(typ reflect.Type) func(fv reflect.Value) error {
table.go#L1472: return func(fv reflect.Value) error {
table.go#L1478: return func(fv reflect.Value) error {
table.go#L1484: return func(fv reflect.Value) error {
table.go#L1493: return func(fv reflect.Value) error {
table.go#L1509: return func(fv reflect.Value) error {
table.go#L1518: return func(fv reflect.Value) error {
table.go#L1528: func setSoftDeleteFallbackFunc(typ reflect.Type) func(fv reflect.Value) error {
table.go#L1534: return func(fv reflect.Value) error {
table_params.go#L7: strct reflect.Value
update.go#L194: func (q *UpdateQuery) appendSetStruct(fmter QueryFormatter, b []byte, strct reflect.Value) ([]byte, error) {
update.go#L308: fmter QueryFormatter, b []byte, fields []*Field, slice reflect.Value,
update.go#L313: b, err = q.appendValues(fmter, b, fields, reflect.Value{})
update.go#L338: fmter QueryFormatter, b []byte, fields []*Field, strct reflect.Value,
util.go#L9: func indirect(v reflect.Value) reflect.Value {
util.go#L27: func sliceElemType(v reflect.Value) reflect.Type {
util.go#L48: func fieldByIndex(v reflect.Value, index []int) (_ reflect.Value, ok bool) {
util.go#L67: func fieldByIndexAlloc(v reflect.Value, index []int) reflect.Value {
util.go#L81: func indirectNil(v reflect.Value) reflect.Value {
util.go#L91: func walk(v reflect.Value, index []int, fn func(reflect.Value)) {
util.go#L104: func visitField(v reflect.Value, index []int, fn func(reflect.Value)) {
util.go#L117: func dstValues(model TableModel, fields []*Field) map[string][]reflect.Value {
util.go#L119: m := make(map[string][]reflect.Value)
util.go#L121: walk(model.Root(), model.ParentIndex(), func(v reflect.Value) {
util.go#L128: func modelID(b []byte, v reflect.Value, fields []*Field) []byte {
github.com/go-pg/pg/v10/types
append_value.go#L23: type AppenderFunc func([]byte, reflect.Value, int) []byte
append_value.go#L126: return func(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L134: func appendValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L142: func appendIfaceValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L146: func appendBoolValue(b []byte, v reflect.Value, _ int) []byte {
append_value.go#L150: func appendIntValue(b []byte, v reflect.Value, _ int) []byte {
append_value.go#L154: func appendUintValue(b []byte, v reflect.Value, _ int) []byte {
append_value.go#L158: func appendFloat32Value(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L162: func appendFloat64Value(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L166: func appendBytesValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L170: func appendArrayBytesValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L186: func appendStringValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L190: func appendStructValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L199: func appendJSONValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L215: func appendTimeValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L220: func appendIPValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L225: func appendIPNetValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L230: func appendJSONRawMessageValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L234: func appendAppenderValue(b []byte, v reflect.Value, flags int) []byte {
append_value.go#L238: func appendDriverValuerValue(b []byte, v reflect.Value, flags int) []byte {
array.go#L9: v reflect.Value
array_append.go#L64: return func(b []byte, v reflect.Value, flags int) []byte {
array_append.go#L106: func appendSliceStringValue(b []byte, v reflect.Value, flags int) []byte {
array_append.go#L139: func appendSliceIntValue(b []byte, v reflect.Value, flags int) []byte {
array_append.go#L172: func appendSliceInt64Value(b []byte, v reflect.Value, flags int) []byte {
array_append.go#L205: func appendSliceFloat64Value(b []byte, v reflect.Value, flags int) []byte {
array_scan.go#L53: return func(v reflect.Value, rd Reader, n int) error {
array_scan.go#L113: func scanStringArrayValue(v reflect.Value, rd Reader, n int) error {
array_scan.go#L150: func scanIntArrayValue(v reflect.Value, rd Reader, n int) error {
array_scan.go#L197: func scanInt64ArrayValue(v reflect.Value, rd Reader, n int) error {
array_scan.go#L244: func scanFloat64ArrayValue(v reflect.Value, rd Reader, n int) error {
array_scan.go#L291: func scanArrayValueScannerValue(v reflect.Value, rd Reader, n int) error {
flags.go#L19: func nilable(v reflect.Value) bool {
hstore.go#L9: v reflect.Value
hstore_append.go#L15: return func(b []byte, v reflect.Value, flags int) []byte {
hstore_append.go#L47: func appendMapStringStringValue(b []byte, v reflect.Value, flags int) []byte {
hstore_scan.go#L12: return func(v reflect.Value, rd Reader, n int) error {
hstore_scan.go#L17: func scanMapStringStringValue(v reflect.Value, rd Reader, n int) error {
in_op.go#L9: slice reflect.Value
in_op.go#L41: func appendIn(b []byte, slice reflect.Value, flags int) []byte {
scan_value.go#L26: type ScannerFunc func(reflect.Value, Reader, int) error
scan_value.go#L136: return func(v reflect.Value, rd Reader, n int) error {
scan_value.go#L163: func scanIfaceValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L170: func ScanValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L186: func scanBoolValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L201: func scanInt64Value(v reflect.Value, rd Reader, n int) error {
scan_value.go#L211: func scanUint64Value(v reflect.Value, rd Reader, n int) error {
scan_value.go#L221: func scanFloat32Value(v reflect.Value, rd Reader, n int) error {
scan_value.go#L231: func scanFloat64Value(v reflect.Value, rd Reader, n int) error {
scan_value.go#L241: func scanStringValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L251: func scanJSONValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L264: func scanTimeValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L276: func scanIPValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L299: func scanIPNetValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L321: func scanJSONRawMessageValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L336: func scanBytesValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L351: func scanArrayBytesValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L364: func scanValueScannerValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L379: func scanValueScannerAddrValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L386: func scanSQLScannerValue(v reflect.Value, rd Reader, n int) error {
scan_value.go#L401: func scanSQLScannerAddrValue(v reflect.Value, rd Reader, n int) error {
github.com/go-pg/zerochecker
zerochecker.go#L20: type Func func(reflect.Value) bool
zerochecker.go#L57: func isZeroInterface(v reflect.Value) bool {
zerochecker.go#L64: func isZeroAppenderValue(v reflect.Value) bool {
zerochecker.go#L77: func isZeroDriverValue(v reflect.Value) bool {
zerochecker.go#L90: func isZeroLen(v reflect.Value) bool {
zerochecker.go#L94: func isNil(v reflect.Value) bool {
zerochecker.go#L98: func isZeroBool(v reflect.Value) bool {
zerochecker.go#L102: func isZeroInt(v reflect.Value) bool {
zerochecker.go#L106: func isZeroUint(v reflect.Value) bool {
zerochecker.go#L110: func isZeroFloat(v reflect.Value) bool {
zerochecker.go#L114: func isZeroBytes(v reflect.Value) bool {
zerochecker.go#L124: func isZeroFalse(v reflect.Value) bool {
github.com/golang/mock/gomock
call.go#L117: vArgs := make([]reflect.Value, len(args))
call.go#L157: vArgs := make([]reflect.Value, len(args))
call.go#L428: func setSlice(arg interface{}, v reflect.Value) {
matchers.go#L260: func (m inAnyOrderMatcher) prepareValue(x interface{}) (reflect.Value, bool) {
matchers.go#L266: return reflect.Value{}, false
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#L301: func (s *state) tryOptions(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L310: func (s *state) tryMethod(t reflect.Type, vx, vy reflect.Value) bool {
compare.go#L322: 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#L347: return f.Call([]reflect.Value{x, y})[0].Bool()
compare.go#L354: c := make(chan reflect.Value)
compare.go#L357: want := f.Call([]reflect.Value{x, y})[0].Bool()
compare.go#L364: func detectRaces(c chan<- reflect.Value, f reflect.Value, vs ...reflect.Value) {
compare.go#L365: var ret reflect.Value
compare.go#L373: func (s *state) compareStruct(t reflect.Type, vx, vy reflect.Value) {
compare.go#L375: var vax, vay reflect.Value // Addressable versions of vx and vy
compare.go#L416: func (s *state) compareSlice(t reflect.Type, vx, vy reflect.Value) {
compare.go#L442: step.vx, step.xkey = reflect.Value{}, -1
compare.go#L447: step.vy, step.ykey = reflect.Value{}, -1
compare.go#L508: func (s *state) compareMap(t reflect.Type, vx, vy reflect.Value) {
compare.go#L550: func (s *state) comparePtr(t reflect.Type, vx, vy reflect.Value) {
compare.go#L567: func (s *state) compareInterface(t reflect.Type, vx, vy reflect.Value) {
compare.go#L662: func makeAddressable(v reflect.Value) reflect.Value {
export_unsafe.go#L23: 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#L43: apply(s *state, vx, vy reflect.Value)
options.go#L68: func (opts Options) filter(s *state, t reflect.Type, vx, vy reflect.Value) (out applicableOption) {
options.go#L89: func (opts Options) apply(s *state, _, _ reflect.Value) {
options.go#L134: func (f pathFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L177: fnc reflect.Value // func(T, T) bool
options.go#L181: func (f valuesFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L203: func (ignore) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption { return ignore{} }
options.go#L204: func (ignore) apply(s *state, _, _ reflect.Value) { s.report(true, reportByIgnore) }
options.go#L212: func (validator) filter(_ *state, _ reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L221: func (validator) apply(s *state, vx, vy reflect.Value) {
options.go#L301: fnc reflect.Value // func(T) R
options.go#L306: func (tr *transformer) filter(s *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L320: func (tr *transformer) apply(s *state, vx, vy reflect.Value) {
options.go#L359: fnc reflect.Value // func(T, T) bool
options.go#L364: func (cm *comparer) filter(_ *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L371: func (cm *comparer) apply(s *state, vx, vy reflect.Value) {
options.go#L414: func (exporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L520: func (reporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
path.go#L53: Values() (vx, vy reflect.Value)
path.go#L155: vx, vy reflect.Value
path.go#L159: func (ps pathStep) Values() (vx, vy reflect.Value) { return ps.vx, ps.vy }
path.go#L183: pvx, pvy reflect.Value // Parent values (always addressable)
path.go#L188: func (sf StructField) Values() (vx, vy reflect.Value) {
path.go#L219: func (si SliceIndex) Values() (vx, vy reflect.Value) { return si.vx, si.vy }
path.go#L259: key reflect.Value
path.go#L263: func (mi MapIndex) Values() (vx, vy reflect.Value) { return mi.vx, mi.vy }
path.go#L267: func (mi MapIndex) Key() reflect.Value { return mi.key }
path.go#L276: func (in Indirect) Values() (vx, vy reflect.Value) { return in.vx, in.vy }
path.go#L286: func (ta TypeAssertion) Values() (vx, vy reflect.Value) { return ta.vx, ta.vy }
path.go#L297: func (tf Transform) Values() (vx, vy reflect.Value) { return tf.vx, tf.vy }
path.go#L304: func (tf Transform) Func() reflect.Value { return tf.trans.fnc }
path.go#L356: func (p pointerPath) Push(vx, vy reflect.Value) (equal, visited bool) {
path.go#L371: func (p pointerPath) Pop(vx, vy reflect.Value) {
report_compare.go#L207: var formatKey func(reflect.Value) string
report_compare.go#L212: formatKey = func(v reflect.Value) string { return v.String() }
report_compare.go#L216: formatKey = func(reflect.Value) string { return "" }
report_compare.go#L220: formatKey = func(v reflect.Value) string { return formatMapKey(v, false, ptrs) }
report_compare.go#L283: var keys []reflect.Value // invariant: len(list) == len(keys)
report_compare.go#L323: keys = append(keys, reflect.Value{})
report_compare.go#L372: keys = append(keys, reflect.Value{})
report_compare.go#L381: 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#L114: func (opts formatOptions) FormatValue(v reflect.Value, parentKind reflect.Kind, ptrs *pointerReferences) (out textNode) {
report_reflect.go#L359: func formatMapKey(v reflect.Value, disambiguate bool, ptrs *pointerReferences) string {
report_slices.go#L166: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L256: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L268: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L300: func(v reflect.Value, d diffMode) textRecord {
report_slices.go#L358: vx, vy reflect.Value, chunkSize int, name string,
report_slices.go#L359: makeRec func(reflect.Value, diffMode) textRecord,
report_slices.go#L368: 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/internal/function
func.go#L71: func NameOf(v reflect.Value) string {
github.com/google/go-cmp/cmp/internal/value
pointer_unsafe.go#L23: 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 {
github.com/vmihailenco/msgpack/v5
decode.go#L307: func (d *Decoder) DecodeValue(v reflect.Value) error {
decode.go#L323: func (d *Decoder) decodeNilValue(v reflect.Value) error {
decode_map.go#L23: func decodeMapValue(d *Decoder, v reflect.Value) error {
decode_map.go#L90: func decodeMapStringStringValue(d *Decoder, v reflect.Value) error {
decode_map.go#L126: func decodeMapStringInterfaceValue(d *Decoder, v reflect.Value) error {
decode_map.go#L236: func (d *Decoder) decodeTypedMapValue(v reflect.Value, n int) error {
decode_map.go#L274: func decodeStructValue(d *Decoder, v reflect.Value) error {
decode_map.go#L310: func (d *Decoder) decodeStruct(v reflect.Value, n int) error {
decode_number.go#L261: func decodeFloat32Value(d *Decoder, v reflect.Value) error {
decode_number.go#L270: func decodeFloat64Value(d *Decoder, v reflect.Value) error {
decode_number.go#L279: func decodeInt64Value(d *Decoder, v reflect.Value) error {
decode_number.go#L288: func decodeUint64Value(d *Decoder, v reflect.Value) error {
decode_slice.go#L38: func decodeStringSliceValue(d *Decoder, v reflect.Value) error {
decode_slice.go#L83: func decodeSliceValue(d *Decoder, v reflect.Value) error {
decode_slice.go#L117: func growSliceValue(v reflect.Value, n int) reflect.Value {
decode_slice.go#L126: func decodeArrayValue(d *Decoder, v reflect.Value) error {
decode_string.go#L62: func decodeStringValue(d *Decoder, v reflect.Value) error {
decode_string.go#L157: func decodeBytesValue(d *Decoder, v reflect.Value) error {
decode_string.go#L173: func decodeByteArrayValue(d *Decoder, v reflect.Value) error {
decode_value.go#L127: return func(d *Decoder, v reflect.Value) error {
decode_value.go#L142: return func(d *Decoder, v reflect.Value) error {
decode_value.go#L152: return func(d *Decoder, v reflect.Value) error {
decode_value.go#L163: return func(d *Decoder, v reflect.Value) error {
decode_value.go#L171: func decodeBoolValue(d *Decoder, v reflect.Value) error {
decode_value.go#L180: func decodeInterfaceValue(d *Decoder, v reflect.Value) error {
decode_value.go#L187: func (d *Decoder) interfaceValue(v reflect.Value) error {
decode_value.go#L207: func decodeUnsupportedValue(d *Decoder, v reflect.Value) error {
decode_value.go#L213: func decodeCustomValue(d *Decoder, v reflect.Value) error {
decode_value.go#L218: func unmarshalValue(d *Decoder, v reflect.Value) error {
decode_value.go#L232: func unmarshalBinaryValue(d *Decoder, v reflect.Value) error {
decode_value.go#L242: func unmarshalTextValue(d *Decoder, v reflect.Value) error {
encode.go#L237: func (e *Encoder) EncodeValue(v reflect.Value) error {
encode_map.go#L11: func encodeMapValue(e *Encoder, v reflect.Value) error {
encode_map.go#L33: func encodeMapStringStringValue(e *Encoder, v reflect.Value) error {
encode_map.go#L59: func encodeMapStringInterfaceValue(e *Encoder, v reflect.Value) error {
encode_map.go#L146: func encodeStructValue(e *Encoder, strct reflect.Value) error {
encode_map.go#L169: func encodeStructValueAsArray(e *Encoder, strct reflect.Value, fields []*field) error {
encode_number.go#L206: func encodeUintValue(e *Encoder, v reflect.Value) error {
encode_number.go#L210: func encodeIntValue(e *Encoder, v reflect.Value) error {
encode_number.go#L214: func encodeUint8CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L218: func encodeUint16CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L222: func encodeUint32CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L226: func encodeUint64CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L230: func encodeInt8CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L234: func encodeInt16CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L238: func encodeInt32CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L242: func encodeInt64CondValue(e *Encoder, v reflect.Value) error {
encode_number.go#L246: func encodeFloat32Value(e *Encoder, v reflect.Value) error {
encode_number.go#L250: func encodeFloat64Value(e *Encoder, v reflect.Value) error {
encode_slice.go#L12: func encodeStringValue(e *Encoder, v reflect.Value) error {
encode_slice.go#L16: func encodeByteSliceValue(e *Encoder, v reflect.Value) error {
encode_slice.go#L20: func encodeByteArrayValue(e *Encoder, v reflect.Value) error {
encode_slice.go#L101: func encodeStringSliceValue(e *Encoder, v reflect.Value) error {
encode_slice.go#L121: func encodeSliceValue(e *Encoder, v reflect.Value) error {
encode_slice.go#L128: func encodeArrayValue(e *Encoder, v reflect.Value) error {
encode_value.go#L125: return func(e *Encoder, v reflect.Value) error {
encode_value.go#L133: func encodeCustomValuePtr(e *Encoder, v reflect.Value) error {
encode_value.go#L141: func encodeCustomValue(e *Encoder, v reflect.Value) error {
encode_value.go#L150: func marshalValuePtr(e *Encoder, v reflect.Value) error {
encode_value.go#L157: func marshalValue(e *Encoder, v reflect.Value) error {
encode_value.go#L171: func encodeBoolValue(e *Encoder, v reflect.Value) error {
encode_value.go#L175: func encodeInterfaceValue(e *Encoder, v reflect.Value) error {
encode_value.go#L182: func encodeErrorValue(e *Encoder, v reflect.Value) error {
encode_value.go#L189: func encodeUnsupportedValue(e *Encoder, v reflect.Value) error {
encode_value.go#L203: func marshalBinaryValueAddr(e *Encoder, v reflect.Value) error {
encode_value.go#L210: func marshalBinaryValue(e *Encoder, v reflect.Value) error {
encode_value.go#L226: func marshalTextValueAddr(e *Encoder, v reflect.Value) error {
encode_value.go#L233: func marshalTextValue(e *Encoder, v reflect.Value) error {
ext.go#L13: Decoder func(d *Decoder, v reflect.Value, extLen int) error
ext.go#L24: RegisterExtEncoder(extID, value, func(e *Encoder, v reflect.Value) ([]byte, error) {
ext.go#L28: RegisterExtDecoder(extID, value, func(d *Decoder, v reflect.Value, extLen int) error {
ext.go#L45: encoder func(enc *Encoder, v reflect.Value) ([]byte, error),
ext.go#L74: encoder func(enc *Encoder, v reflect.Value) ([]byte, error),
ext.go#L78: return func(e *Encoder, v reflect.Value) error {
ext.go#L97: return func(e *Encoder, v reflect.Value) error {
ext.go#L108: decoder func(dec *Decoder, v reflect.Value, extLen int) error,
ext.go#L143: decoder func(d *Decoder, v reflect.Value, extLen int) error,
ext.go#L145: return nilAwareDecoder(typ, func(d *Decoder, v reflect.Value) error {
ext.go#L158: return func(d *Decoder, v reflect.Value) error {
intern.go#L25: func decodeInternedStringExt(d *Decoder, v reflect.Value, extLen int) error {
intern.go#L42: func encodeInternedInterfaceValue(e *Encoder, v reflect.Value) error {
intern.go#L54: func encodeInternedStringValue(e *Encoder, v reflect.Value) error {
intern.go#L104: func decodeInternedInterfaceValue(d *Decoder, v reflect.Value) error {
intern.go#L122: func decodeInternedStringValue(d *Decoder, v reflect.Value) error {
time.go#L19: func timeEncoder(e *Encoder, v reflect.Value) ([]byte, error) {
time.go#L23: func timeDecoder(d *Decoder, v reflect.Value, extLen int) error {
types.go#L36: encoderFunc func(*Encoder, reflect.Value) error
types.go#L37: decoderFunc func(*Decoder, reflect.Value) error
types.go#L100: func (f *field) Omit(strct reflect.Value, forced bool) bool {
types.go#L108: func (f *field) EncodeValue(e *Encoder, strct reflect.Value) error {
types.go#L116: func (f *field) DecodeValue(d *Decoder, strct reflect.Value) error {
types.go#L155: func (fs *fields) OmitEmpty(strct reflect.Value, forced bool) []*field {
types.go#L320: func isEmptyValue(v reflect.Value) bool {
types.go#L353: func fieldByIndex(v reflect.Value, index []int) (_ reflect.Value, ok bool) {
types.go#L373: func fieldByIndexAlloc(v reflect.Value, index []int) reflect.Value {
types.go#L392: func indirectNil(v reflect.Value) (reflect.Value, bool) {
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) {
google.golang.org/protobuf/internal/descfmt
stringer.go#L94: v := m.Call([]reflect.Value{reflect.ValueOf(i)})[0].Interface()
stringer.go#L207: func (rs *records) Append(v reflect.Value, accessors ...string) {
stringer.go#L209: var rv reflect.Value
google.golang.org/protobuf/internal/impl
codec_field.go#L57: var vw reflect.Value // pointer to wrapper type
codec_field.go#L825: func asMessage(v reflect.Value) protoreflect.ProtoMessage {
codec_map.go#L91: func sizeMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) int {
codec_map.go#L114: func consumeMap(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L171: func consumeMapOfMessage(b []byte, mapv reflect.Value, wtyp protowire.Type, mapi *mapInfo, f *coderFieldInfo, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L235: func appendMapItem(b []byte, keyrv, valrv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L266: func appendMap(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L285: func appendMapDeterministic(b []byte, mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo, opts marshalOptions) ([]byte, error) {
codec_map.go#L314: func isInitMap(mapv reflect.Value, mapi *mapInfo, f *coderFieldInfo) error {
codec_map_go112.go#L12: func mapRange(v reflect.Value) *reflect.MapIter { return v.MapRange() }
convert.go#L23: PBValueOf(reflect.Value) protoreflect.Value
convert.go#L26: GoValueOf(protoreflect.Value) reflect.Value
convert.go#L32: IsValidGo(reflect.Value) bool
convert.go#L151: func (c *boolConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L157: func (c *boolConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L164: func (c *boolConverter) IsValidGo(v reflect.Value) bool {
convert.go#L175: func (c *int32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L181: func (c *int32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L188: func (c *int32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L199: func (c *int64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L205: func (c *int64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L212: func (c *int64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L223: func (c *uint32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L229: func (c *uint32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L236: func (c *uint32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L247: func (c *uint64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L253: func (c *uint64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L260: func (c *uint64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L271: func (c *float32Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L277: func (c *float32Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L284: func (c *float32Converter) IsValidGo(v reflect.Value) bool {
convert.go#L295: func (c *float64Converter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L301: func (c *float64Converter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L308: func (c *float64Converter) IsValidGo(v reflect.Value) bool {
convert.go#L319: func (c *stringConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L325: func (c *stringConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L338: func (c *stringConverter) IsValidGo(v reflect.Value) bool {
convert.go#L349: func (c *bytesConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L358: func (c *bytesConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L365: func (c *bytesConverter) IsValidGo(v reflect.Value) bool {
convert.go#L386: func (c *enumConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L393: func (c *enumConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L402: func (c *enumConverter) IsValidGo(v reflect.Value) bool {
convert.go#L422: func (c *messageConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert.go#L439: func (c *messageConverter) GoValueOf(v protoreflect.Value) reflect.Value {
convert.go#L441: var rv reflect.Value
convert.go#L465: var rv reflect.Value
convert.go#L477: func (c *messageConverter) IsValidGo(v reflect.Value) bool {
convert_list.go#L29: func (c *listConverter) PBValueOf(v reflect.Value) protoreflect.Value {
convert_list.go#L38: func (c *listConverter) GoValueOf(v protoreflect.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) protoreflect.Value {
convert_list.go#L78: func (c *listPtrConverter) GoValueOf(v protoreflect.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) protoreflect.Value {
convert_map.go#L37: func (c *mapConverter) GoValueOf(v protoreflect.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#L36: func legacyWrapEnum(v reflect.Value) protoreflect.Enum {
legacy_message.go#L24: func legacyWrapMessage(v reflect.Value) protoreflect.Message {
legacy_message.go#L211: for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
legacy_message.go#L223: vs := fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))})[0]
legacy_message.go#L486: v reflect.Value
message.go#L197: for _, v := range fn.Func.Call([]reflect.Value{reflect.Zero(fn.Type.In(0))}) {
message_reflect_field.go#L509: func isZero(v reflect.Value) bool {
pointer_unsafe.go#L48: func pointerOfValue(v reflect.Value) pointer {
pointer_unsafe.go#L77: func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
gotest.tools/v3/assert/cmp
compare.go#L265: msgFunc := func(value reflect.Value) string {
compare.go#L271: func isNil(obj interface{}, msgFunc func(reflect.Value) string) Comparison {
internal/buildcfg
exp.go#L138: var rBase reflect.Value
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 {
testing
fuzz.go#L325: args := []reflect.Value{reflect.ValueOf(t)}
text/template
exec.go#L45: value reflect.Value
exec.go#L49: func (s *state) push(name string, value reflect.Value) {
exec.go#L65: func (s *state) setVar(name string, value reflect.Value) {
exec.go#L76: func (s *state) setTopVar(n int, value reflect.Value) {
exec.go#L81: func (s *state) varValue(name string) reflect.Value {
exec.go#L91: var zero reflect.Value
exec.go#L206: value, ok := data.(reflect.Value)
exec.go#L255: func (s *state) walk(dot reflect.Value, node parse.Node) {
exec.go#L293: func (s *state) walkIfOrWith(typ parse.NodeType, dot reflect.Value, pipe *parse.PipeNode, list, elseList *parse.ListNode) {
exec.go#L318: func isTrue(val reflect.Value) (truth, ok bool) {
exec.go#L346: func (s *state) walkRange(dot reflect.Value, r *parse.RangeNode) {
exec.go#L357: oneIteration := func(index, elem reflect.Value) {
exec.go#L423: func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
exec.go#L450: func (s *state) evalPipeline(dot reflect.Value, pipe *parse.PipeNode) (value reflect.Value) {
exec.go#L473: func (s *state) notAFunction(args []parse.Node, final reflect.Value) {
exec.go#L479: func (s *state) evalCommand(dot reflect.Value, cmd *parse.CommandNode, final reflect.Value) reflect.Value {
exec.go#L518: func (s *state) idealConstant(constant *parse.NumberNode) reflect.Value {
exec.go#L553: func (s *state) evalFieldNode(dot reflect.Value, field *parse.FieldNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L558: func (s *state) evalChainNode(dot reflect.Value, chain *parse.ChainNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L571: func (s *state) evalVariableNode(dot reflect.Value, variable *parse.VariableNode, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L585: func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ident []string, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L594: func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L607: func (s *state) evalField(dot reflect.Value, fieldName string, node parse.Node, args []parse.Node, final, receiver reflect.Value) reflect.Value {
exec.go#L691: reflectValueType = reflect.TypeOf((*reflect.Value)(nil)).Elem()
exec.go#L697: func (s *state) evalCall(dot, fun reflect.Value, isBuiltin bool, node parse.Node, name string, args []parse.Node, final reflect.Value) reflect.Value {
exec.go#L720: unwrap := func(v reflect.Value) reflect.Value {
exec.go#L722: v = v.Interface().(reflect.Value)
exec.go#L730: var v reflect.Value
exec.go#L732: v = s.evalArg(dot, argType, arg).Interface().(reflect.Value)
exec.go#L752: argv := make([]reflect.Value, numIn)
exec.go#L803: func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value {
exec.go#L845: func (s *state) evalArg(dot reflect.Value, typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L892: func (s *state) evalBool(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L903: func (s *state) evalString(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L914: func (s *state) evalInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L925: func (s *state) evalUnsignedInteger(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L936: func (s *state) evalFloat(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L947: func (s *state) evalComplex(typ reflect.Type, n parse.Node) reflect.Value {
exec.go#L957: func (s *state) evalEmptyInterface(dot reflect.Value, n parse.Node) reflect.Value {
exec.go#L987: func indirect(v reflect.Value) (rv reflect.Value, isNil bool) {
exec.go#L1000: func indirectInterface(v reflect.Value) reflect.Value {
exec.go#L1005: return reflect.Value{}
exec.go#L1012: func (s *state) printValue(n parse.Node, v reflect.Value) {
exec.go#L1026: func printableValue(v reflect.Value) (any, bool) {
funcs.go#L68: v map[string]reflect.Value
funcs.go#L73: func builtinFuncs() map[string]reflect.Value {
funcs.go#L81: func createValueFuncs(funcMap FuncMap) map[string]reflect.Value {
funcs.go#L82: m := make(map[string]reflect.Value)
funcs.go#L88: func addValueFuncs(out map[string]reflect.Value, in FuncMap) {
funcs.go#L142: func findFunction(name string, tmpl *Template) (v reflect.Value, isBuiltin, ok bool) {
funcs.go#L153: return reflect.Value{}, false, false
funcs.go#L158: func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
funcs.go#L161: return reflect.Value{}, fmt.Errorf("value is nil; should be of type %s", argType)
funcs.go#L172: return reflect.Value{}, fmt.Errorf("value has type %s; should be %s", value.Type(), argType)
funcs.go#L186: func indexArg(index reflect.Value, cap int) (int, error) {
funcs.go#L209: func index(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
funcs.go#L212: return reflect.Value{}, fmt.Errorf("index of untyped nil")
funcs.go#L218: return reflect.Value{}, fmt.Errorf("index of nil pointer")
funcs.go#L224: return reflect.Value{}, err
funcs.go#L230: return reflect.Value{}, err
funcs.go#L241: return reflect.Value{}, fmt.Errorf("can't index item of type %s", item.Type())
funcs.go#L253: func slice(item reflect.Value, indexes ...reflect.Value) (reflect.Value, error) {
funcs.go#L256: return reflect.Value{}, fmt.Errorf("slice of untyped nil")
funcs.go#L259: return reflect.Value{}, fmt.Errorf("too many slice indexes: %d", len(indexes))
funcs.go#L265: return reflect.Value{}, fmt.Errorf("cannot 3-index slice a string")
funcs.go#L271: return reflect.Value{}, fmt.Errorf("can't slice item of type %s", item.Type())
funcs.go#L278: return reflect.Value{}, err
funcs.go#L284: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[0], idx[1])
funcs.go#L291: return reflect.Value{}, fmt.Errorf("invalid slice index: %d > %d", idx[1], idx[2])
funcs.go#L299: func length(item reflect.Value) (int, error) {
funcs.go#L315: func call(fn reflect.Value, args ...reflect.Value) (reflect.Value, error) {
funcs.go#L318: return reflect.Value{}, fmt.Errorf("call of nil")
funcs.go#L322: return reflect.Value{}, fmt.Errorf("non-function of type %s", typ)
funcs.go#L325: return reflect.Value{}, fmt.Errorf("function called with %d args; should be 1 or 2", typ.NumOut())
funcs.go#L331: return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want at least %d", len(args), numIn-1)
funcs.go#L336: return reflect.Value{}, fmt.Errorf("wrong number of args: got %d want %d", len(args), numIn)
funcs.go#L339: argv := make([]reflect.Value, len(args))
funcs.go#L350: return reflect.Value{}, fmt.Errorf("arg %d: %w", i, err)
funcs.go#L358: func safeCall(fun reflect.Value, args []reflect.Value) (val reflect.Value, err error) {
funcs.go#L377: func truth(arg reflect.Value) bool {
funcs.go#L384: func and(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
funcs.go#L390: func or(arg0 reflect.Value, args ...reflect.Value) reflect.Value {
funcs.go#L395: func not(arg reflect.Value) bool {
funcs.go#L421: func basicKind(v reflect.Value) (kind, error) {
funcs.go#L440: func eq(arg1 reflect.Value, arg2 ...reflect.Value) (bool, error) {
funcs.go#L500: func ne(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L507: func lt(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L549: func le(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L559: func gt(arg1, arg2 reflect.Value) (bool, error) {
funcs.go#L569: func ge(arg1, arg2 reflect.Value) (bool, error) {
template.go#L23: execFuncs map[string]reflect.Value
template.go#L75: c.execFuncs = make(map[string]reflect.Value)