type reflect.Type
378 uses
reflect (current package)
deepequal.go#L18: typ Type
makefunc.go#L48: func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value {
type.go#L38: type Type interface {
type.go#L103: Implements(u Type) bool
type.go#L106: AssignableTo(u Type) bool
type.go#L109: ConvertibleTo(u Type) bool
type.go#L151: Elem() Type
type.go#L185: In(i int) Type
type.go#L189: Key() Type
type.go#L210: Out(i int) Type
type.go#L579: Type Type // method type
type.go#L817: in := make([]Type, 0, 1+len(ft.in()))
type.go#L822: out := make([]Type, 0, len(ft.out()))
type.go#L897: func (t *rtype) Elem() Type {
type.go#L950: func (t *rtype) In(i int) Type {
type.go#L958: func (t *rtype) Key() Type {
type.go#L998: func (t *rtype) Out(i int) Type {
type.go#L1098: Type Type // field type
type.go#L1368: func TypeOf(i interface{}) Type {
type.go#L1378: func PtrTo(t Type) Type {
type.go#L1433: func (t *rtype) Implements(u Type) bool {
type.go#L1443: func (t *rtype) AssignableTo(u Type) bool {
type.go#L1451: func (t *rtype) ConvertibleTo(u Type) bool {
type.go#L1585: func haveIdenticalType(T, V Type, cmpTags bool) bool {
type.go#L1779: func ChanOf(dir ChanDir, t Type) Type {
type.go#L1818: return ti.(Type)
type.go#L1833: return ti.(Type)
type.go#L1842: func MapOf(key, elem Type) Type {
type.go#L1853: return mt.(Type)
type.go#L1862: return ti.(Type)
type.go#L1906: return ti.(Type)
type.go#L1943: func FuncOf(in, out []Type, variadic bool) Type {
type.go#L2032: addToCache := func(tt *rtype) Type {
type.go#L2287: func SliceOf(t Type) Type {
type.go#L2293: return slice.(Type)
type.go#L2302: return ti.(Type)
type.go#L2317: return ti.(Type)
type.go#L2368: func StructOf(fields []StructField) Type {
type.go#L2645: for _, st := range ts.([]Type) {
type.go#L2657: for _, st := range ts.([]Type) {
type.go#L2665: addToCache := func(t Type) Type {
type.go#L2666: var ts []Type
type.go#L2668: ts = ti.([]Type)
type.go#L2832: func ArrayOf(count int, elem Type) Type {
type.go#L2838: return array.(Type)
type.go#L2847: return ti.(Type)
type.go#L2957: return ti.(Type)
type.go#L2973: func toType(t *rtype) Type {
value.go#L1905: func (v Value) Type() Type {
value.go#L2000: func typesMustMatch(what string, t1, t2 Type) {
value.go#L2289: func MakeSlice(typ Type, len, cap int) Value {
value.go#L2308: func MakeChan(typ Type, buffer int) Value {
value.go#L2324: func MakeMap(typ Type) Value {
value.go#L2330: func MakeMapWithSize(typ Type, n int) Value {
value.go#L2370: func Zero(typ Type) Value {
value.go#L2396: func New(typ Type) Value {
value.go#L2408: func NewAt(typ Type, p unsafe.Pointer) Value {
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#L2576: func makeFloat(f flag, v float64, t Type) Value {
value.go#L2589: func makeFloat32(f flag, v float32, t Type) Value {
value.go#L2598: func makeComplex(f flag, v complex128, t Type) Value {
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#L2736: func cvtT2I(v Value, typ Type) Value {
value.go#L2748: func cvtI2I(v Value, typ Type) Value {
contrib.go.opencensus.io/integrations/ocsql
driver.go#L650: ColumnTypeScanType(index int) reflect.Type
database/sql
sql.go#L2986: scanType reflect.Type
sql.go#L3012: func (ci *ColumnType) ScanType() reflect.Type {
database/sql/driver
driver.go#L460: ColumnTypeScanType(index int) reflect.Type
encoding/asn1
asn1.go#L605: func parseSequenceOf(bytes []byte, sliceType reflect.Type, elemType reflect.Type) (ret reflect.Value, err error) {
asn1.go#L1096: Type reflect.Type
common.go#L158: func getUniversalType(t reflect.Type) (matchAny bool, tagNumber int, isCompound, ok bool) {
encoding/binary
binary.go#L428: func sizeof(t reflect.Type) int {
encoding/gob
decode.go#L559: func (dec *Decoder) decodeMap(mtyp reflect.Type, state *decoderState, value reflect.Value, keyOp, elemOp decOp, ovfl error) {
decode.go#L641: func (dec *Decoder) decodeInterface(ityp reflect.Type, state *decoderState, value reflect.Value) {
decode.go#L667: typ := typi.(reflect.Type)
decode.go#L790: func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string, inProgress map[reflect.Type]*decOp) *decOp {
decode.go#L969: func (dec *Decoder) compatibleType(fr reflect.Type, fw typeId, inProgress map[reflect.Type]typeId) bool {
decode.go#L1057: if !dec.compatibleType(rt, remoteId, make(map[reflect.Type]typeId)) {
decode.go#L1065: op := dec.decOpFor(remoteId, rt, name, make(map[reflect.Type]*decOp))
decode.go#L1109: seen := make(map[reflect.Type]*decOp)
decode.go#L1125: if !dec.compatibleType(localField.Type, wireField.Id, make(map[reflect.Type]typeId)) {
decode.go#L1257: func allocValue(t reflect.Type) reflect.Value {
decoder.go#L32: decoderCache map[reflect.Type]map[typeId]**decEngine // cache of compiled engines
decoder.go#L50: dec.decoderCache = make(map[reflect.Type]map[typeId]**decEngine)
encode.go#L516: func encOpFor(rt reflect.Type, inProgress map[reflect.Type]*encOp, building map[*typeInfo]bool) (*encOp, int) {
encode.go#L631: seen := make(map[reflect.Type]*encOp)
encoder.go#L20: sent map[reflect.Type]typeId // which types we've already sent
encoder.go#L37: enc.sent = make(map[reflect.Type]typeId)
encoder.go#L93: func (enc *Encoder) sendActualType(w io.Writer, state *encoderState, ut *userTypeInfo, actual reflect.Type) (sent bool) {
encoder.go#L135: func (enc *Encoder) sendType(w io.Writer, state *encoderState, origt reflect.Type) (sent bool) {
type.go#L23: user reflect.Type // the type the user handed us
type.go#L24: base reflect.Type // the base type after all indirections
type.go#L44: func validUserType(rt reflect.Type) (*userTypeInfo, error) {
type.go#L118: func implementsInterface(typ, gobEncDecType reflect.Type) (success bool, indir int8) {
type.go#L151: func userType(rt reflect.Type) *userTypeInfo {
type.go#L175: var types = make(map[reflect.Type]gobType)
type.go#L438: func newTypeObject(name string, ut *userTypeInfo, rt reflect.Type) (gobType, error) {
type.go#L583: func getBaseType(name string, rt reflect.Type) (gobType, error) {
type.go#L593: func getType(name string, ut *userTypeInfo, rt reflect.Type) (gobType, error) {
type.go#L688: func lookupTypeInfo(rt reflect.Type) *typeInfo {
type.go#L689: m, _ := typeInfoMap.Load().(map[reflect.Type]*typeInfo)
type.go#L707: func buildTypeInfo(ut *userTypeInfo, rt reflect.Type) (*typeInfo, error) {
type.go#L754: newm := make(map[reflect.Type]*typeInfo)
type.go#L755: m, _ := typeInfoMap.Load().(map[reflect.Type]*typeInfo)
type.go#L765: func mustGetTypeInfo(rt reflect.Type) *typeInfo {
encoding/json
decode.go#L126: Type reflect.Type // type of Go value it could not be assigned to
decode.go#L145: Type reflect.Type
decode.go#L156: Type reflect.Type
decode.go#L210: Struct reflect.Type
encode.go#L232: Type reflect.Type
encode.go#L266: Type reflect.Type
encode.go#L381: func typeEncoder(t reflect.Type) encoderFunc {
encode.go#L417: func newTypeEncoder(t reflect.Type, allowAddr bool) encoderFunc {
encode.go#L770: func newStructEncoder(t reflect.Type) encoderFunc {
encode.go#L819: func newMapEncoder(t reflect.Type) encoderFunc {
encode.go#L892: func newSliceEncoder(t reflect.Type) encoderFunc {
encode.go#L920: func newArrayEncoder(t reflect.Type) encoderFunc {
encode.go#L948: func newPtrEncoder(t reflect.Type) encoderFunc {
encode.go#L989: func typeByIndex(t reflect.Type, index []int) reflect.Type {
encode.go#L1183: typ reflect.Type
encode.go#L1212: func typeFields(t reflect.Type) structFields {
encode.go#L1218: var count, nextCount map[reflect.Type]int
encode.go#L1221: visited := map[reflect.Type]bool{}
encode.go#L1231: count, nextCount = nextCount, map[reflect.Type]int{}
encode.go#L1412: func cachedTypeFields(t reflect.Type) structFields {
encoding/xml
marshal.go#L638: func defaultStart(typ reflect.Type, finfo *fieldInfo, startTemplate *StartElement) StartElement {
marshal.go#L754: func (p *printer) marshalSimple(typ reflect.Type, val reflect.Value) (string, []byte, error) {
marshal.go#L1035: Type reflect.Type
typeinfo.go#L53: func getTypeInfo(typ reflect.Type) (*typeInfo, error) {
typeinfo.go#L113: func structFieldInfo(typ reflect.Type, f *reflect.StructField) (*fieldInfo, error) {
typeinfo.go#L231: func lookupXMLName(typ reflect.Type) (xmlname *fieldInfo) {
typeinfo.go#L268: func addFieldInfo(typ reflect.Type, tinfo *typeInfo, newf *fieldInfo) error {
typeinfo.go#L338: Struct reflect.Type
github.com/ghodss/yaml
fields.go#L75: typ reflect.Type
fields.go#L130: func typeFields(t reflect.Type) []field {
fields.go#L136: count := map[reflect.Type]int{}
fields.go#L137: nextCount := map[reflect.Type]int{}
fields.go#L140: visited := map[reflect.Type]bool{}
fields.go#L147: count, nextCount = nextCount, map[reflect.Type]int{}
fields.go#L288: m map[reflect.Type][]field
fields.go#L292: func cachedTypeFields(t reflect.Type) []field {
fields.go#L309: fieldCache.m = map[reflect.Type][]field{}
github.com/go-git/gcfg
set.go#L104: var typeModes = map[reflect.Type]types.IntMode{
set.go#L119: func intModeDefault(t reflect.Type) types.IntMode {
set.go#L166: var typeSetters = map[reflect.Type]setter{
set.go#L196: vType reflect.Type) (reflect.Value, error) {
github.com/golang/protobuf/proto
properties.go#L91: Type reflect.Type
properties.go#L196: func (p *Properties) Init(typ reflect.Type, name, tag string, f *reflect.StructField) {
properties.go#L219: func GetProperties(t reflect.Type) *StructProperties {
properties.go#L227: func newProperties(t reflect.Type) *StructProperties {
registry.go#L212: func MessageType(s messageName) reflect.Type {
registry.go#L214: return v.(reflect.Type)
registry.go#L218: var t reflect.Type
registry.go#L237: return v.(reflect.Type)
registry.go#L242: func goTypeForField(fd protoreflect.FieldDescriptor) reflect.Type {
registry.go#L259: func enumGoType(et protoreflect.EnumType) reflect.Type {
registry.go#L263: func messageGoType(mt protoreflect.MessageType) reflect.Type {
github.com/google/go-cmp/cmp
compare.go#L144: var t reflect.Type
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#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#L431: func (s *state) compareSlice(t reflect.Type, vx, vy reflect.Value) {
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) {
options.go#L32: filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption
options.go#L66: func (opts Options) filter(s *state, t reflect.Type, vx, vy reflect.Value) (out applicableOption) {
options.go#L132: func (f pathFilter) filter(s *state, t reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L174: typ reflect.Type // T
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#L210: func (validator) filter(_ *state, _ reflect.Type, vx, vy reflect.Value) applicableOption {
options.go#L298: typ reflect.Type // T
options.go#L304: func (tr *transformer) filter(s *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L356: typ reflect.Type // T
options.go#L362: func (cm *comparer) filter(_ *state, t reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L403: func Exporter(f func(reflect.Type) bool) Option {
options.go#L410: type exporter func(reflect.Type) bool
options.go#L412: func (exporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
options.go#L421: m := make(map[reflect.Type]bool)
options.go#L429: return exporter(func(t reflect.Type) bool { return m[t] })
options.go#L518: func (reporter) filter(_ *state, _ reflect.Type, _, _ reflect.Value) applicableOption {
path.go#L38: Type() reflect.Type
path.go#L152: typ reflect.Type
path.go#L156: func (ps pathStep) Type() reflect.Type { return ps.typ }
path.go#L185: func (sf StructField) Type() reflect.Type { return sf.typ }
path.go#L216: func (si SliceIndex) Type() reflect.Type { return si.typ }
path.go#L260: func (mi MapIndex) Type() reflect.Type { return mi.typ }
path.go#L273: func (in Indirect) Type() reflect.Type { return in.typ }
path.go#L283: func (ta TypeAssertion) Type() reflect.Type { return ta.typ }
path.go#L294: func (tf Transform) Type() reflect.Type { return tf.typ }
report_reflect.go#L44: func (opts formatOptions) FormatType(t reflect.Type, s textNode) textNode {
report_value.go#L15: Type reflect.Type
github.com/google/go-cmp/cmp/cmpopts
ignore.go#L36: type typeFilter []reflect.Type
ignore.go#L71: type ifaceFilter []reflect.Type
ignore.go#L124: type unexportedFilter struct{ m map[reflect.Type]bool }
ignore.go#L127: ux := unexportedFilter{m: make(map[reflect.Type]bool)}
sort.go#L39: in reflect.Type // T
sort.go#L110: in reflect.Type // T
struct_filter.go#L31: t reflect.Type // The root struct type to match on
struct_filter.go#L141: func canonicalName(t reflect.Type, sel string) ([]string, error) {
github.com/google/go-cmp/cmp/internal/function
func.go#L38: func IsType(t reflect.Type, ft funcType) bool {
github.com/google/go-cmp/cmp/internal/value
name.go#L14: func TypeString(t reflect.Type, qualified bool) string {
name.go#L18: func appendTypeName(b []byte, t reflect.Type, qualified, elideFunc bool) []byte {
pointer_unsafe.go#L17: t reflect.Type
github.com/imdario/mergo
merge.go#L50: Transformer(reflect.Type) func(dst, src reflect.Value) error
mergo.go#L31: typ reflect.Type
github.com/jackc/pgtype
convert.go#L388: var kindTypes map[reflect.Kind]reflect.Type
convert.go#L439: kindTypes = map[reflect.Kind]reflect.Type{
pgtype.go#L235: reflectTypeToName map[reflect.Type]string
pgtype.go#L239: reflectTypeToDataType map[reflect.Type]*DataType
pgtype.go#L246: reflectTypeToName: make(map[reflect.Type]string),
pgtype.go#L429: ci.reflectTypeToDataType = make(map[reflect.Type]*DataType)
github.com/jackc/pgx/v4/stdlib
sql.go#L494: func (r *Rows) ColumnTypeScanType(index int) reflect.Type {
github.com/lann/builder
builder.go#L89: func listToSlice(list ps.List, arrayType reflect.Type) reflect.Value {
registry.go#L9: registry = make(map[reflect.Type]reflect.Type)
registry.go#L21: func RegisterType(builderType reflect.Type, structType reflect.Type) *reflect.Value {
registry.go#L42: func getBuilderStructType(builderType reflect.Type) *reflect.Type {
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) {
rows.go#L24: func (fd fieldDesc) Type() reflect.Type {
rows.go#L73: func (rs *rows) ColumnTypeScanType(index int) reflect.Type {
golang.org/x/crypto/ssh
messages.go#L346: func typeTags(structType reflect.Type) (tags []byte) {
messages.go#L359: func fieldError(t reflect.Type, field int, problem string) error {
golang.org/x/pkgsite/internal/database
reflect.go#L53: func structScannerForType(t reflect.Type) func(p interface{}) []interface{} {
golang.org/x/pkgsite/internal/godoc/codec
codec.go#L21: typeNums map[reflect.Type]int
codec.go#L28: typeNums: map[reflect.Type]int{},
codec.go#L550: typeInfosByType = map[reflect.Type]*typeInfo{}
codec.go#L570: func typeName(t reflect.Type) string {
codec.go#L577: var builtinTypes []reflect.Type
generate.go#L75: done: map[reflect.Type]bool{},
generate.go#L127: todo []reflect.Type
generate.go#L128: done map[reflect.Type]bool
generate.go#L179: func (g *generator) gen(t reflect.Type) ([]byte, error) {
generate.go#L193: func (g *generator) genSlice(t reflect.Type) ([]byte, error) {
generate.go#L197: Type, ElType reflect.Type
generate.go#L204: func (g *generator) genMap(t reflect.Type) ([]byte, error) {
generate.go#L209: Type, ElType, KeyType reflect.Type
generate.go#L217: func (g *generator) genStruct(t reflect.Type) ([]byte, error) {
generate.go#L235: Type reflect.Type
generate.go#L246: Type reflect.Type
generate.go#L262: func exportedFields(t reflect.Type, oldNames []string) []field {
generate.go#L314: func zeroValue(t reflect.Type) string {
generate.go#L342: func (g *generator) encodeStatement(t reflect.Type, arg string) string {
generate.go#L358: func (g *generator) decodeStatement(t reflect.Type, arg string) string {
generate.go#L384: func builtinName(t reflect.Type) (suffix string, native reflect.Type) {
generate.go#L407: func (g *generator) goName(t reflect.Type) string {
generate.go#L428: func (g *generator) funcName(t reflect.Type) string {
google.golang.org/protobuf/internal/descfmt
stringer.go#L106: var descriptorAccessors = map[reflect.Type][]string{
google.golang.org/protobuf/internal/encoding/tag
tag.go#L32: func Unmarshal(tag string, goType reflect.Type, evs pref.EnumValueDescriptors) pref.FieldDescriptor {
google.golang.org/protobuf/internal/filetype
build.go#L217: var goType reflect.Type
build.go#L245: var goTypeForPBKind = map[pref.Kind]reflect.Type{
google.golang.org/protobuf/internal/impl
codec_field.go#L34: oneofFields := make(map[reflect.Type]*coderFieldInfo)
codec_field.go#L191: func makeMessageFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L346: func makeGroupFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L437: func makeMessageSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L521: func sizeMessageSlice(p pointer, goType reflect.Type, tagsize int, _ marshalOptions) int {
codec_field.go#L531: func appendMessageSlice(b []byte, p pointer, wiretag uint64, goType reflect.Type, opts marshalOptions) ([]byte, error) {
codec_field.go#L547: func consumeMessageSlice(b []byte, p pointer, goType reflect.Type, wtyp protowire.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_field.go#L569: func isInitMessageSlice(p pointer, goType reflect.Type) error {
codec_field.go#L708: func makeGroupSliceFieldCoder(fd pref.FieldDescriptor, ft reflect.Type) pointerCoderFuncs {
codec_field.go#L739: func sizeGroupSlice(p pointer, messageType reflect.Type, tagsize int, _ marshalOptions) int {
codec_field.go#L749: func appendGroupSlice(b []byte, p pointer, wiretag uint64, messageType reflect.Type, opts marshalOptions) ([]byte, error) {
codec_field.go#L764: func consumeGroupSlice(b []byte, p pointer, num protowire.Number, wtyp protowire.Type, goType reflect.Type, opts unmarshalOptions) (out unmarshalOutput, err error) {
codec_map.go#L18: goType reflect.Type
codec_map.go#L28: func encoderFuncsForMap(fd pref.FieldDescriptor, ft reflect.Type) (valueMessage *MessageInfo, funcs pointerCoderFuncs) {
codec_message.go#L39: ft reflect.Type
codec_message.go#L49: func (mi *MessageInfo) makeCoderMethods(t reflect.Type, si structInfo) {
codec_tables.go#L37: func fieldCoder(fd pref.FieldDescriptor, ft reflect.Type) (*MessageInfo, pointerCoderFuncs) {
convert.go#L53: func NewConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
convert.go#L90: func newSingularConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
convert.go#L147: goType reflect.Type
convert.go#L171: goType reflect.Type
convert.go#L195: goType reflect.Type
convert.go#L219: goType reflect.Type
convert.go#L243: goType reflect.Type
convert.go#L267: goType reflect.Type
convert.go#L291: goType reflect.Type
convert.go#L315: goType reflect.Type
convert.go#L345: goType reflect.Type
convert.go#L372: goType reflect.Type
convert.go#L376: func newEnumConverter(goType reflect.Type, fd pref.FieldDescriptor) Converter {
convert.go#L415: goType reflect.Type
convert.go#L418: func newMessageConverter(goType reflect.Type) Converter {
convert_list.go#L14: func newListConverter(t reflect.Type, fd pref.FieldDescriptor) Converter {
convert_list.go#L25: goType reflect.Type // []T
convert_list.go#L67: goType reflect.Type // *[]T
convert_map.go#L15: goType reflect.Type // map[K]V
convert_map.go#L19: func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
enum.go#L14: GoReflectType reflect.Type // int32 kind
extension.go#L38: goType reflect.Type
extension.go#L86: func InitExtensionInfo(xi *ExtensionInfo, xd pref.ExtensionDescriptor, goType reflect.Type) {
legacy_enum.go#L46: func legacyLoadEnumType(t reflect.Type) pref.EnumType {
legacy_enum.go#L67: goType reflect.Type
legacy_enum.go#L86: goTyp reflect.Type
legacy_enum.go#L118: func LegacyLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
legacy_enum.go#L161: func aberrantLoadEnumDesc(t reflect.Type) pref.EnumDescriptor {
legacy_enum.go#L195: func AberrantDeriveFullName(t reflect.Type) pref.FullName {
legacy_message.go#L40: func legacyLoadMessageInfo(t reflect.Type, name pref.FullName) *MessageInfo {
legacy_message.go#L81: func LegacyLoadMessageDesc(t reflect.Type) pref.MessageDescriptor {
legacy_message.go#L84: func legacyLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
legacy_message.go#L146: aberrantMessageDescCache map[reflect.Type]protoreflect.MessageDescriptor
legacy_message.go#L154: func aberrantLoadMessageDesc(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
legacy_message.go#L158: aberrantMessageDescCache = make(map[reflect.Type]protoreflect.MessageDescriptor)
legacy_message.go#L162: func aberrantLoadMessageDescReentrant(t reflect.Type, name pref.FullName) pref.MessageDescriptor {
legacy_message.go#L197: var oneofWrappers []reflect.Type
legacy_message.go#L257: func aberrantDeriveMessageName(t reflect.Type, name pref.FullName) pref.FullName {
legacy_message.go#L276: func aberrantAppendField(md *filedesc.Message, goType reflect.Type, tag, tagKey, tagVal string) {
legacy_message.go#L421: t reflect.Type
legacy_message.go#L430: func (mt aberrantMessageType) GoType() reflect.Type {
message.go#L28: GoReflectType reflect.Type // pointer to struct
message.go#L55: func getMessageInfo(mt reflect.Type) *MessageInfo {
message.go#L131: oneofWrappersByType map[reflect.Type]pref.FieldNumber
message.go#L132: oneofWrappersByNumber map[pref.FieldNumber]reflect.Type
message.go#L135: func (mi *MessageInfo) makeStructInfo(t reflect.Type) structInfo {
message.go#L144: oneofWrappersByType: map[reflect.Type]pref.FieldNumber{},
message.go#L145: oneofWrappersByNumber: map[pref.FieldNumber]reflect.Type{},
message_reflect.go#L35: func (mi *MessageInfo) makeReflectFuncs(t reflect.Type, si structInfo) {
message_reflect.go#L97: func (mi *MessageInfo) makeUnknownFieldsFunc(t reflect.Type, si structInfo) {
message_reflect.go#L127: func (mi *MessageInfo) makeExtensionFieldsFunc(t reflect.Type, si structInfo) {
message_reflect_field.go#L31: func fieldInfoForOneof(fd pref.FieldDescriptor, fs reflect.StructField, x exporter, ot reflect.Type) fieldInfo {
pointer_unsafe.go#L76: func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
pointer_unsafe.go#L82: func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
validate.go#L109: func newFieldValidationInfo(mi *MessageInfo, si structInfo, fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
validate.go#L145: func newValidationInfo(fd pref.FieldDescriptor, ft reflect.Type) validationInfo {
gopkg.in/yaml.v2
decode.go#L229: mapType reflect.Type
decode.go#L733: var elemType reflect.Type
yaml.go#L307: var structMap = make(map[reflect.Type]*structInfo)
yaml.go#L310: func getStructInfo(st reflect.Type) (*structInfo, error) {
text/template
exec.go#L739: func canBeNil(typ reflect.Type) bool {
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 {
funcs.go#L110: func goodFunc(typ reflect.Type) bool {
funcs.go#L155: func prepareArg(value reflect.Value, argType reflect.Type) (reflect.Value, error) {
funcs.go#L325: var dddType reflect.Type
 |
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. |