Involved Source Filesdeepequal.gomakefunc.goswapper.go
Package reflect implements run-time reflection, allowing a program to
manipulate objects with arbitrary types. The typical use is to take a value
with static type interface{} and extract its dynamic type information by
calling TypeOf, which returns a Type.
A call to ValueOf returns a Value representing the run-time data.
Zero takes a Type and returns a Value representing a zero value
for that type.
See "The Laws of Reflection" for an introduction to reflection in Go:
https://golang.org/doc/articles/laws_of_reflection.html
value.goasm_amd64.s
Code Examples
package main
import (
"fmt"
"reflect"
)
func main() {
for _, v := range []interface{}{"hi", 42, func() {}} {
switch v := reflect.ValueOf(v); v.Kind() {
case reflect.String:
fmt.Println(v.String())
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
fmt.Println(v.Int())
default:
fmt.Printf("unhandled kind %s", v.Kind())
}
}
}
package main
import (
"fmt"
"reflect"
)
func main() {
// swap is the implementation passed to MakeFunc.
// It must work in terms of reflect.Values so that it is possible
// to write code without knowing beforehand what the types
// will be.
swap := func(in []reflect.Value) []reflect.Value {
return []reflect.Value{in[1], in[0]}
}
// makeSwap expects fptr to be a pointer to a nil function.
// It sets that pointer to a new function created with MakeFunc.
// When the function is invoked, reflect turns the arguments
// into Values, calls swap, and then turns swap's result slice
// into the values returned by the new function.
makeSwap := func(fptr interface{}) {
// fptr is a pointer to a function.
// Obtain the function value itself (likely nil) as a reflect.Value
// so that we can query its type and then set the value.
fn := reflect.ValueOf(fptr).Elem()
// Make a function of the right type.
v := reflect.MakeFunc(fn.Type(), swap)
// Assign it to the value fn represents.
fn.Set(v)
}
// Make and call a swap function for ints.
var intSwap func(int, int) (int, int)
makeSwap(&intSwap)
fmt.Println(intSwap(0, 1))
// Make and call a swap function for float64s.
var floatSwap func(float64, float64) (float64, float64)
makeSwap(&floatSwap)
fmt.Println(floatSwap(2.72, 3.14))
}
package main
import (
"bytes"
"encoding/json"
"fmt"
"reflect"
)
func main() {
typ := reflect.StructOf([]reflect.StructField{
{
Name: "Height",
Type: reflect.TypeOf(float64(0)),
Tag: `json:"height"`,
},
{
Name: "Age",
Type: reflect.TypeOf(int(0)),
Tag: `json:"age"`,
},
})
v := reflect.New(typ).Elem()
v.Field(0).SetFloat(0.4)
v.Field(1).SetInt(2)
s := v.Addr().Interface()
w := new(bytes.Buffer)
if err := json.NewEncoder(w).Encode(s); err != nil {
panic(err)
}
fmt.Printf("value: %+v\n", s)
fmt.Printf("json: %s", w.Bytes())
r := bytes.NewReader([]byte(`{"height":1.5,"age":10}`))
if err := json.NewDecoder(r).Decode(s); err != nil {
panic(err)
}
fmt.Printf("value: %+v\n", s)
}
package main
import (
"fmt"
"reflect"
)
func main() {
type S struct {
F string `species:"gopher" color:"blue"`
}
s := S{}
st := reflect.TypeOf(s)
field := st.Field(0)
fmt.Println(field.Tag.Get("color"), field.Tag.Get("species"))
}
package main
import (
"fmt"
"reflect"
)
func main() {
type S struct {
F0 string `alias:"field_0"`
F1 string `alias:""`
F2 string
}
s := S{}
st := reflect.TypeOf(s)
for i := 0; i < st.NumField(); i++ {
field := st.Field(i)
if alias, ok := field.Tag.Lookup("alias"); ok {
if alias == "" {
fmt.Println("(blank)")
} else {
fmt.Println(alias)
}
} else {
fmt.Println("(not specified)")
}
}
}
package main
import (
"fmt"
"io"
"os"
"reflect"
)
func main() {
// As interface types are only used for static typing, a
// common idiom to find the reflection Type for an interface
// type Foo is to use a *Foo value.
writerType := reflect.TypeOf((*io.Writer)(nil)).Elem()
fileType := reflect.TypeOf((*os.File)(nil))
fmt.Println(fileType.Implements(writerType))
}
Package-Level Type Names (total 50, in which 13 are exported)
A MapIter is an iterator for ranging over a map.
See Value.MapRange.
itunsafe.PointermValue
Key returns the key of the iterator's current map entry.
Next advances the map iterator and reports whether there is another
entry. It returns false when the iterator is exhausted; subsequent
calls to Key, Value, or Next will panic.
Value returns the value of the iterator's current map entry.
func Value.MapRange() *MapIter
Method represents a single method.
// func with receiver as first argument
// index for Type.Method
Name is the method name.
PkgPath is the package path that qualifies a lower case (unexported)
method name. It is empty for upper case (exported) method names.
The combination of PkgPath and Name uniquely identifies a method
in a method set.
See https://golang.org/ref/spec#Uniqueness_of_identifiers
PkgPathstring
// method type
func Type.Method(int) Method
func Type.MethodByName(string) (Method, bool)
A SelectCase describes a single case in a select operation.
The kind of case depends on Dir, the communication direction.
If Dir is SelectDefault, the case represents a default case.
Chan and Send must be zero Values.
If Dir is SelectSend, the case represents a send operation.
Normally Chan's underlying value must be a channel, and Send's underlying value must be
assignable to the channel's element type. As a special case, if Chan is a zero Value,
then the case is ignored, and the field Send will also be ignored and may be either zero
or non-zero.
If Dir is SelectRecv, the case represents a receive operation.
Normally Chan's underlying value must be a channel and Send must be a zero Value.
If Chan is a zero Value, then the case is ignored, but Send must still be a zero Value.
When a receive operation is selected, the received Value is returned by Select.
// channel to use (for send or receive)
// direction of case
// value to send (for send)
func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool)
SliceHeader is the runtime representation of a slice.
It cannot be used safely or portably and its representation may
change in a later release.
Moreover, the Data field is not sufficient to guarantee the data
it references will not be garbage collected, so programs must keep
a separate, correctly typed pointer to the underlying data.
CapintDatauintptrLenint
StringHeader is the runtime representation of a string.
It cannot be used safely or portably and its representation may
change in a later release.
Moreover, the Data field is not sufficient to guarantee the data
it references will not be garbage collected, so programs must keep
a separate, correctly typed pointer to the underlying data.
DatauintptrLenint
A StructField describes a single field in a struct.
// is an embedded field
// index sequence for Type.FieldByIndex
Name is the field name.
// offset within struct, in bytes
PkgPath is the package path that qualifies a lower case (unexported)
field name. It is empty for upper case (exported) field names.
See https://golang.org/ref/spec#Uniqueness_of_identifiers
// field tag string
// field type
func Type.Field(i int) StructField
func Type.FieldByIndex(index []int) StructField
func Type.FieldByName(name string) (StructField, bool)
func Type.FieldByNameFunc(match func(string) bool) (StructField, bool)
func StructOf(fields []StructField) Type
func runtimeStructField(field StructField) (structField, string)
A StructTag is the tag string in a struct field.
By convention, tag strings are a concatenation of
optionally space-separated key:"value" pairs.
Each key is a non-empty string consisting of non-control
characters other than space (U+0020 ' '), quote (U+0022 '"'),
and colon (U+003A ':'). Each value is quoted using U+0022 '"'
characters and Go string literal syntax.
Get returns the value associated with key in the tag string.
If there is no such key in the tag, Get returns the empty string.
If the tag does not have the conventional format, the value
returned by Get is unspecified. To determine whether a tag is
explicitly set to the empty string, use Lookup.
Lookup returns the value associated with key in the tag string.
If the key is present in the tag the value (which may be empty)
is returned. Otherwise the returned value will be the empty string.
The ok return value reports whether the value was explicitly set in
the tag string. If the tag does not have the conventional format,
the value returned by Lookup is unspecified.
Type is the representation of a Go type.
Not all methods apply to all kinds of types. Restrictions,
if any, are noted in the documentation for each method.
Use the Kind method to find out the kind of type before
calling kind-specific methods. Calling a method
inappropriate to the kind of type causes a run-time panic.
Type values are comparable, such as with the == operator,
so they can be used as map keys.
Two Type values are equal if they represent identical types.
Align returns the alignment in bytes of a value of
this type when allocated in memory.
AssignableTo reports whether a value of the type is assignable to type u.
Bits returns the size of the type in bits.
It panics if the type's Kind is not one of the
sized or unsized Int, Uint, Float, or Complex kinds.
ChanDir returns a channel type's direction.
It panics if the type's Kind is not Chan.
Comparable reports whether values of this type are comparable.
ConvertibleTo reports whether a value of the type is convertible to type u.
Elem returns a type's element type.
It panics if the type's Kind is not Array, Chan, Map, Ptr, or Slice.
Field returns a struct type's i'th field.
It panics if the type's Kind is not Struct.
It panics if i is not in the range [0, NumField()).
FieldAlign returns the alignment in bytes of a value of
this type when used as a field in a struct.
FieldByIndex returns the nested field corresponding
to the index sequence. It is equivalent to calling Field
successively for each index i.
It panics if the type's Kind is not Struct.
FieldByName returns the struct field with the given name
and a boolean indicating if the field was found.
FieldByNameFunc returns the struct field with a name
that satisfies the match function and a boolean indicating if
the field was found.
FieldByNameFunc considers the fields in the struct itself
and then the fields in any embedded structs, in breadth first order,
stopping at the shallowest nesting depth containing one or more
fields satisfying the match function. If multiple fields at that depth
satisfy the match function, they cancel each other
and FieldByNameFunc returns no match.
This behavior mirrors Go's handling of name lookup in
structs containing embedded fields.
Implements reports whether the type implements the interface type u.
In returns the type of a function type's i'th input parameter.
It panics if the type's Kind is not Func.
It panics if i is not in the range [0, NumIn()).
IsVariadic reports whether a function type's final input parameter
is a "..." parameter. If so, t.In(t.NumIn() - 1) returns the parameter's
implicit actual type []T.
For concreteness, if t represents func(x int, y ... float64), then
t.NumIn() == 2
t.In(0) is the reflect.Type for "int"
t.In(1) is the reflect.Type for "[]float64"
t.IsVariadic() == true
IsVariadic panics if the type's Kind is not Func.
Key returns a map type's key type.
It panics if the type's Kind is not Map.
Kind returns the specific kind of this type.
Len returns an array type's length.
It panics if the type's Kind is not Array.
Method returns the i'th method in the type's method set.
It panics if i is not in the range [0, NumMethod()).
For a non-interface type T or *T, the returned Method's Type and Func
fields describe a function whose first argument is the receiver,
and only exported methods are accessible.
For an interface type, the returned Method's Type field gives the
method signature, without a receiver, and the Func field is nil.
Methods are sorted in lexicographic order.
MethodByName returns the method with that name in the type's
method set and a boolean indicating if the method was found.
For a non-interface type T or *T, the returned Method's Type and Func
fields describe a function whose first argument is the receiver.
For an interface type, the returned Method's Type field gives the
method signature, without a receiver, and the Func field is nil.
Name returns the type's name within its package for a defined type.
For other (non-defined) types it returns the empty string.
NumField returns a struct type's field count.
It panics if the type's Kind is not Struct.
NumIn returns a function type's input parameter count.
It panics if the type's Kind is not Func.
NumMethod returns the number of methods accessible using Method.
Note that NumMethod counts unexported methods only for interface types.
NumOut returns a function type's output parameter count.
It panics if the type's Kind is not Func.
Out returns the type of a function type's i'th output parameter.
It panics if the type's Kind is not Func.
It panics if i is not in the range [0, NumOut()).
PkgPath returns a defined type's package path, that is, the import path
that uniquely identifies the package, such as "encoding/base64".
If the type was predeclared (string, error) or not defined (*T, struct{},
[]int, or A where A is an alias for a non-defined type), the package path
will be the empty string.
Size returns the number of bytes needed to store
a value of the given type; it is analogous to unsafe.Sizeof.
String returns a string representation of the type.
The string representation may use shortened package names
(e.g., base64 instead of "encoding/base64") and is not
guaranteed to be unique among types. To test for type identity,
compare the Types directly.
( T) common() *rtype( T) uncommon() *uncommonType
*arrayType
*chanType
*funcType
*funcTypeFixed128
*funcTypeFixed16
*funcTypeFixed32
*funcTypeFixed4
*funcTypeFixed64
*funcTypeFixed8
*interfaceType
*mapType
*ptrType
*rtype
*sliceType
*structType
*structTypeUncommon
T : fmt.Stringer
T : github.com/neo4j/neo4j-go-driver/v4/neo4j.DatabaseInfo
T : context.stringer
T : runtime.stringer
func ArrayOf(count int, elem Type) Type
func ChanOf(dir ChanDir, t Type) Type
func FuncOf(in, out []Type, variadic bool) Type
func MapOf(key, elem Type) Type
func PtrTo(t Type) Type
func SliceOf(t Type) Type
func StructOf(fields []StructField) Type
func TypeOf(i interface{}) Type
func Type.Elem() Type
func Type.In(i int) Type
func Type.Key() Type
func Type.Out(i int) Type
func Value.Type() Type
func toType(t *rtype) Type
func encoding/json.typeByIndex(t Type, index []int) Type
func gitlab.com/pcanilho/goneo.asRefType(typ Type) Type
func ArrayOf(count int, elem Type) Type
func ChanOf(dir ChanDir, t Type) Type
func FuncOf(in, out []Type, variadic bool) Type
func MakeChan(typ Type, buffer int) Value
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value
func MakeMap(typ Type) Value
func MakeMapWithSize(typ Type, n int) Value
func MakeSlice(typ Type, len, cap int) Value
func MapOf(key, elem Type) Type
func New(typ Type) Value
func NewAt(typ Type, p unsafe.Pointer) Value
func PtrTo(t Type) Type
func SliceOf(t Type) Type
func Zero(typ Type) Value
func Type.AssignableTo(u Type) bool
func Type.ConvertibleTo(u Type) bool
func Type.Implements(u Type) bool
func Value.Convert(t Type) Value
func cvtBytesString(v Value, t Type) Value
func cvtComplex(v Value, t Type) Value
func cvtDirect(v Value, typ Type) Value
func cvtFloat(v Value, t Type) Value
func cvtFloatInt(v Value, t Type) Value
func cvtFloatUint(v Value, t Type) Value
func cvtI2I(v Value, typ Type) Value
func cvtInt(v Value, t Type) Value
func cvtIntFloat(v Value, t Type) Value
func cvtIntString(v Value, t Type) Value
func cvtRunesString(v Value, t Type) Value
func cvtStringBytes(v Value, t Type) Value
func cvtStringRunes(v Value, t Type) Value
func cvtT2I(v Value, typ Type) Value
func cvtUint(v Value, t Type) Value
func cvtUintFloat(v Value, t Type) Value
func cvtUintString(v Value, t Type) Value
func haveIdenticalType(T, V Type, cmpTags bool) bool
func makeBytes(f flag, v []byte, t Type) Value
func makeComplex(f flag, v complex128, t Type) Value
func makeFloat(f flag, v float64, t Type) Value
func makeFloat32(f flag, v float32, t Type) Value
func makeInt(f flag, bits uint64, t Type) Value
func makeRunes(f flag, v []rune, t Type) Value
func makeString(f flag, v string, t Type) Value
func typesMustMatch(what string, t1, t2 Type)
func encoding/asn1.getUniversalType(t Type) (matchAny bool, tagNumber int, isCompound, ok bool)
func encoding/asn1.parseSequenceOf(bytes []byte, sliceType Type, elemType Type) (ret Value, err error)
func encoding/asn1.parseSequenceOf(bytes []byte, sliceType Type, elemType Type) (ret Value, err error)
func encoding/binary.sizeof(t Type) int
func encoding/json.cachedTypeFields(t Type) json.structFields
func encoding/json.newArrayEncoder(t Type) json.encoderFunc
func encoding/json.newMapEncoder(t Type) json.encoderFunc
func encoding/json.newPtrEncoder(t Type) json.encoderFunc
func encoding/json.newSliceEncoder(t Type) json.encoderFunc
func encoding/json.newStructEncoder(t Type) json.encoderFunc
func encoding/json.newTypeEncoder(t Type, allowAddr bool) json.encoderFunc
func encoding/json.typeByIndex(t Type, index []int) Type
func encoding/json.typeEncoder(t Type) json.encoderFunc
func encoding/json.typeFields(t Type) json.structFields
func gitlab.com/pcanilho/goneo.asRefType(typ Type) Type
var encoding/asn1.bigIntType
var encoding/asn1.bitStringType
var encoding/asn1.enumeratedType
var encoding/asn1.flagType
var encoding/asn1.objectIdentifierType
var encoding/asn1.rawContentsType
var encoding/asn1.rawValueType
var encoding/asn1.timeType
var encoding/json.marshalerType
var encoding/json.numberType
var encoding/json.textMarshalerType
var encoding/json.textUnmarshalerType
var vendor/golang.org/x/crypto/cryptobyte.bigIntType
Value is the reflection interface to a Go value.
Not all methods apply to all kinds of values. Restrictions,
if any, are noted in the documentation for each method.
Use the Kind method to find out the kind of value before
calling kind-specific methods. Calling a method
inappropriate to the kind of type causes a run time panic.
The zero Value represents no value.
Its IsValid method returns false, its Kind method returns Invalid,
its String method returns "<invalid Value>", and all other methods panic.
Most functions and methods never return an invalid value.
If one does, its documentation states the conditions explicitly.
A Value can be used concurrently by multiple goroutines provided that
the underlying Go value can be used concurrently for the equivalent
direct operations.
To compare two Values, compare the results of the Interface method.
Using == on two Values does not compare the underlying values
they represent.
flag holds metadata about the value.
The lowest bits are flag bits:
- flagStickyRO: obtained via unexported not embedded field, so read-only
- flagEmbedRO: obtained via unexported embedded field, so read-only
- flagIndir: val holds a pointer to the data
- flagAddr: v.CanAddr is true (implies flagIndir)
- flagMethod: v is a method value.
The next five bits give the Kind of the value.
This repeats typ.Kind() except for method values.
The remaining 23+ bits give a method number for method values.
If flag.kind() != Func, code can assume that flagMethod is unset.
If ifaceIndir(typ), code can assume that flagIndir is set.
Pointer-valued data or, if flagIndir is set, pointer to data.
Valid when either flagIndir is set or typ.pointers() is true.
typ holds the type of the value represented by a Value.
Addr returns a pointer value representing the address of v.
It panics if CanAddr() returns false.
Addr is typically used to obtain a pointer to a struct field
or slice element in order to call a method that requires a
pointer receiver.
Bool returns v's underlying value.
It panics if v's kind is not Bool.
Bytes returns v's underlying value.
It panics if v's underlying value is not a slice of bytes.
Call calls the function v with the input arguments in.
For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]).
Call panics if v's Kind is not Func.
It returns the output results as Values.
As in Go, each input argument must be assignable to the
type of the function's corresponding input parameter.
If v is a variadic function, Call creates the variadic slice parameter
itself, copying in the corresponding values.
CallSlice calls the variadic function v with the input arguments in,
assigning the slice in[len(in)-1] to v's final variadic argument.
For example, if len(in) == 3, v.CallSlice(in) represents the Go call v(in[0], in[1], in[2]...).
CallSlice panics if v's Kind is not Func or if v is not variadic.
It returns the output results as Values.
As in Go, each input argument must be assignable to the
type of the function's corresponding input parameter.
CanAddr reports whether the value's address can be obtained with Addr.
Such values are called addressable. A value is addressable if it is
an element of a slice, an element of an addressable array,
a field of an addressable struct, or the result of dereferencing a pointer.
If CanAddr returns false, calling Addr will panic.
CanInterface reports whether Interface can be used without panicking.
CanSet reports whether the value of v can be changed.
A Value can be changed only if it is addressable and was not
obtained by the use of unexported struct fields.
If CanSet returns false, calling Set or any type-specific
setter (e.g., SetBool, SetInt) will panic.
Cap returns v's capacity.
It panics if v's Kind is not Array, Chan, or Slice.
Close closes the channel v.
It panics if v's Kind is not Chan.
Complex returns v's underlying value, as a complex128.
It panics if v's Kind is not Complex64 or Complex128
Convert returns the value v converted to type t.
If the usual Go conversion rules do not allow conversion
of the value v to type t, Convert panics.
Elem returns the value that the interface v contains
or that the pointer v points to.
It panics if v's Kind is not Interface or Ptr.
It returns the zero Value if v is nil.
Field returns the i'th field of the struct v.
It panics if v's Kind is not Struct or i is out of range.
FieldByIndex returns the nested field corresponding to index.
It panics if v's Kind is not struct.
FieldByName returns the struct field with the given name.
It returns the zero Value if no field was found.
It panics if v's Kind is not struct.
FieldByNameFunc returns the struct field with a name
that satisfies the match function.
It panics if v's Kind is not struct.
It returns the zero Value if no field was found.
Float returns v's underlying value, as a float64.
It panics if v's Kind is not Float32 or Float64
Index returns v's i'th element.
It panics if v's Kind is not Array, Slice, or String or i is out of range.
Int returns v's underlying value, as an int64.
It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64.
Interface returns v's current value as an interface{}.
It is equivalent to:
var i interface{} = (v's underlying value)
It panics if the Value was obtained by accessing
unexported struct fields.
InterfaceData returns the interface v's value as a uintptr pair.
It panics if v's Kind is not Interface.
IsNil reports whether its argument v is nil. The argument must be
a chan, func, interface, map, pointer, or slice value; if it is
not, IsNil panics. Note that IsNil is not always equivalent to a
regular comparison with nil in Go. For example, if v was created
by calling ValueOf with an uninitialized interface variable i,
i==nil will be true but v.IsNil will panic as v will be the zero
Value.
IsValid reports whether v represents a value.
It returns false if v is the zero Value.
If IsValid returns false, all other methods except String panic.
Most functions and methods never return an invalid Value.
If one does, its documentation states the conditions explicitly.
IsZero reports whether v is the zero value for its type.
It panics if the argument is invalid.
Kind returns v's Kind.
If v is the zero Value (IsValid returns false), Kind returns Invalid.
Len returns v's length.
It panics if v's Kind is not Array, Chan, Map, Slice, or String.
MapIndex returns the value associated with key in the map v.
It panics if v's Kind is not Map.
It returns the zero Value if key is not found in the map or if v represents a nil map.
As in Go, the key's value must be assignable to the map's key type.
MapKeys returns a slice containing all the keys present in the map,
in unspecified order.
It panics if v's Kind is not Map.
It returns an empty slice if v represents a nil map.
MapRange returns a range iterator for a map.
It panics if v's Kind is not Map.
Call Next to advance the iterator, and Key/Value to access each entry.
Next returns false when the iterator is exhausted.
MapRange follows the same iteration semantics as a range statement.
Example:
iter := reflect.ValueOf(m).MapRange()
for iter.Next() {
k := iter.Key()
v := iter.Value()
...
}
Method returns a function value corresponding to v's i'th method.
The arguments to a Call on the returned function should not include
a receiver; the returned function will always use v as the receiver.
Method panics if i is out of range or if v is a nil interface value.
MethodByName returns a function value corresponding to the method
of v with the given name.
The arguments to a Call on the returned function should not include
a receiver; the returned function will always use v as the receiver.
It returns the zero Value if no method was found.
NumField returns the number of fields in the struct v.
It panics if v's Kind is not Struct.
NumMethod returns the number of exported methods in the value's method set.
OverflowComplex reports whether the complex128 x cannot be represented by v's type.
It panics if v's Kind is not Complex64 or Complex128.
OverflowFloat reports whether the float64 x cannot be represented by v's type.
It panics if v's Kind is not Float32 or Float64.
OverflowInt reports whether the int64 x cannot be represented by v's type.
It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64.
OverflowUint reports whether the uint64 x cannot be represented by v's type.
It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
Pointer returns v's value as a uintptr.
It returns uintptr instead of unsafe.Pointer so that
code using reflect cannot obtain unsafe.Pointers
without importing the unsafe package explicitly.
It panics if v's Kind is not Chan, Func, Map, Ptr, Slice, or UnsafePointer.
If v's Kind is Func, the returned pointer is an underlying
code pointer, but not necessarily enough to identify a
single function uniquely. The only guarantee is that the
result is zero if and only if v is a nil func Value.
If v's Kind is Slice, the returned pointer is to the first
element of the slice. If the slice is nil the returned value
is 0. If the slice is empty but non-nil the return value is non-zero.
Recv receives and returns a value from the channel v.
It panics if v's Kind is not Chan.
The receive blocks until a value is ready.
The boolean value ok is true if the value x corresponds to a send
on the channel, false if it is a zero value received because the channel is closed.
Send sends x on the channel v.
It panics if v's kind is not Chan or if x's type is not the same type as v's element type.
As in Go, x's value must be assignable to the channel's element type.
Set assigns x to the value v.
It panics if CanSet returns false.
As in Go, x's value must be assignable to v's type.
SetBool sets v's underlying value.
It panics if v's Kind is not Bool or if CanSet() is false.
SetBytes sets v's underlying value.
It panics if v's underlying value is not a slice of bytes.
SetCap sets v's capacity to n.
It panics if v's Kind is not Slice or if n is smaller than the length or
greater than the capacity of the slice.
SetComplex sets v's underlying value to x.
It panics if v's Kind is not Complex64 or Complex128, or if CanSet() is false.
SetFloat sets v's underlying value to x.
It panics if v's Kind is not Float32 or Float64, or if CanSet() is false.
SetInt sets v's underlying value to x.
It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64, or if CanSet() is false.
SetLen sets v's length to n.
It panics if v's Kind is not Slice or if n is negative or
greater than the capacity of the slice.
SetMapIndex sets the element associated with key in the map v to elem.
It panics if v's Kind is not Map.
If elem is the zero Value, SetMapIndex deletes the key from the map.
Otherwise if v holds a nil map, SetMapIndex will panic.
As in Go, key's elem must be assignable to the map's key type,
and elem's value must be assignable to the map's elem type.
SetPointer sets the unsafe.Pointer value v to x.
It panics if v's Kind is not UnsafePointer.
SetString sets v's underlying value to x.
It panics if v's Kind is not String or if CanSet() is false.
SetUint sets v's underlying value to x.
It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64, or if CanSet() is false.
Slice returns v[i:j].
It panics if v's Kind is not Array, Slice or String, or if v is an unaddressable array,
or if the indexes are out of bounds.
Slice3 is the 3-index form of the slice operation: it returns v[i:j:k].
It panics if v's Kind is not Array or Slice, or if v is an unaddressable array,
or if the indexes are out of bounds.
String returns the string v's underlying value, as a string.
String is a special case because of Go's String method convention.
Unlike the other getters, it does not panic if v's Kind is not String.
Instead, it returns a string of the form "<T value>" where T is v's type.
The fmt package treats Values specially. It does not call their String
method implicitly but instead prints the concrete values they hold.
TryRecv attempts to receive a value from the channel v but will not block.
It panics if v's Kind is not Chan.
If the receive delivers a value, x is the transferred value and ok is true.
If the receive cannot finish without blocking, x is the zero Value and ok is false.
If the channel is closed, x is the zero value for the channel's element type and ok is false.
TrySend attempts to send x on the channel v but will not block.
It panics if v's Kind is not Chan.
It reports whether the value was sent.
As in Go, x's value must be assignable to the channel's element type.
Type returns v's type.
Uint returns v's underlying value, as a uint64.
It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
UnsafeAddr returns a pointer to v's data.
It is for advanced clients that also import the "unsafe" package.
It panics if v is not addressable.
assignTo returns a value v that can be assigned directly to typ.
It panics if v is not assignable to typ.
For a conversion to an interface type, target is a suggested scratch space to use.
target must be initialized memory (or nil).
( T) call(op string, in []Value) []Value( T) kind() Kind
mustBe panics if f's kind is not expected.
Making this a method on flag instead of on Value
(and embedding flag in Value) means that we can write
the very clear v.mustBe(Bool) and have it compile into
v.flag.mustBe(Bool), which will only bother to copy the
single important word for the receiver.
mustBeAssignable panics if f records that the value is not assignable,
which is to say that either it was obtained using an unexported field
or it is not addressable.
( T) mustBeAssignableSlow()
mustBeExported panics if f records that the value was obtained using
an unexported field.
( T) mustBeExportedSlow()
pointer returns the underlying pointer represented by v.
v.Kind() must be Ptr, Map, Chan, Func, or UnsafePointer
if v.Kind() == Ptr, the base type must not be go:notinheap.
internal recv, possibly non-blocking (nb).
v is known to be a channel.
( T) ro() flag
runes returns v's underlying value.
It panics if v's underlying value is not a slice of runes (int32s).
internal send, possibly non-blocking.
v is known to be a channel.
setRunes sets v's underlying value.
It panics if v's underlying value is not a slice of runes (int32s).
T : fmt.Stringer
T : context.stringer
T : runtime.stringer
func Append(s Value, x ...Value) Value
func AppendSlice(s, t Value) Value
func Indirect(v Value) Value
func MakeChan(typ Type, buffer int) Value
func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value
func MakeMap(typ Type) Value
func MakeMapWithSize(typ Type, n int) Value
func MakeSlice(typ Type, len, cap int) Value
func New(typ Type) Value
func NewAt(typ Type, p unsafe.Pointer) Value
func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool)
func ValueOf(i interface{}) Value
func Zero(typ Type) Value
func (*MapIter).Key() Value
func (*MapIter).Value() Value
func Value.Addr() Value
func Value.Call(in []Value) []Value
func Value.CallSlice(in []Value) []Value
func Value.Convert(t Type) Value
func Value.Elem() Value
func Value.Field(i int) Value
func Value.FieldByIndex(index []int) Value
func Value.FieldByName(name string) Value
func Value.FieldByNameFunc(match func(string) bool) Value
func Value.Index(i int) Value
func Value.MapIndex(key Value) Value
func Value.MapKeys() []Value
func Value.Method(i int) Value
func Value.MethodByName(name string) Value
func Value.Recv() (x Value, ok bool)
func Value.Slice(i, j int) Value
func Value.Slice3(i, j, k int) Value
func Value.TryRecv() (x Value, ok bool)
func copyVal(typ *rtype, fl flag, ptr unsafe.Pointer) Value
func cvtBytesString(v Value, t Type) Value
func cvtComplex(v Value, t Type) Value
func cvtDirect(v Value, typ Type) Value
func cvtFloat(v Value, t Type) Value
func cvtFloatInt(v Value, t Type) Value
func cvtFloatUint(v Value, t Type) Value
func cvtI2I(v Value, typ Type) Value
func cvtInt(v Value, t Type) Value
func cvtIntFloat(v Value, t Type) Value
func cvtIntString(v Value, t Type) Value
func cvtRunesString(v Value, t Type) Value
func cvtStringBytes(v Value, t Type) Value
func cvtStringRunes(v Value, t Type) Value
func cvtT2I(v Value, typ Type) Value
func cvtUint(v Value, t Type) Value
func cvtUintFloat(v Value, t Type) Value
func cvtUintString(v Value, t Type) Value
func grow(s Value, extra int) (Value, int, int)
func makeBytes(f flag, v []byte, t Type) Value
func makeComplex(f flag, v complex128, t Type) Value
func makeFloat(f flag, v float64, t Type) Value
func makeFloat32(f flag, v float32, t Type) Value
func makeInt(f flag, bits uint64, t Type) Value
func makeMethodValue(op string, v Value) Value
func makeRunes(f flag, v []rune, t Type) Value
func makeString(f flag, v string, t Type) Value
func unpackEface(i interface{}) Value
func Value.assignTo(context string, dst *rtype, target unsafe.Pointer) Value
func Value.call(op string, in []Value) []Value
func Value.recv(nb bool) (val Value, ok bool)
func encoding/asn1.parseSequenceOf(bytes []byte, sliceType Type, elemType Type) (ret Value, err error)
func encoding/json.indirect(v Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, Value)
func fmt.getField(v Value, i int) Value
func gitlab.com/pcanilho/goneo.asRef(val Value) Value
func Append(s Value, x ...Value) Value
func Append(s Value, x ...Value) Value
func AppendSlice(s, t Value) Value
func Copy(dst, src Value) int
func Indirect(v Value) Value
func Value.Call(in []Value) []Value
func Value.CallSlice(in []Value) []Value
func Value.MapIndex(key Value) Value
func Value.Send(x Value)
func Value.Set(x Value)
func Value.SetMapIndex(key, elem Value)
func Value.TrySend(x Value) bool
func internal/fmtsort.Sort(mapValue Value) *fmtsort.SortedMap
func cvtBytesString(v Value, t Type) Value
func cvtComplex(v Value, t Type) Value
func cvtDirect(v Value, typ Type) Value
func cvtFloat(v Value, t Type) Value
func cvtFloatInt(v Value, t Type) Value
func cvtFloatUint(v Value, t Type) Value
func cvtI2I(v Value, typ Type) Value
func cvtInt(v Value, t Type) Value
func cvtIntFloat(v Value, t Type) Value
func cvtIntString(v Value, t Type) Value
func cvtRunesString(v Value, t Type) Value
func cvtStringBytes(v Value, t Type) Value
func cvtStringRunes(v Value, t Type) Value
func cvtT2I(v Value, typ Type) Value
func cvtUint(v Value, t Type) Value
func cvtUintFloat(v Value, t Type) Value
func cvtUintString(v Value, t Type) Value
func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool
func grow(s Value, extra int) (Value, int, int)
func makeMethodValue(op string, v Value) Value
func methodReceiver(op string, v Value, methodIndex int) (rcvrtype *rtype, t *funcType, fn unsafe.Pointer)
func packEface(v Value) interface{}
func storeRcvr(v Value, p unsafe.Pointer)
func valueInterface(v Value, safe bool) interface{}
func Value.call(op string, in []Value) []Value
func Value.send(x Value, nb bool) (selected bool)
func encoding/asn1.makeBody(value Value, params asn1.fieldParameters) (e asn1.encoder, err error)
func encoding/asn1.makeField(v Value, params asn1.fieldParameters) (e asn1.encoder, err error)
func encoding/asn1.parseField(v Value, bytes []byte, initOffset int, params asn1.fieldParameters) (offset int, err error)
func encoding/asn1.setDefaultValue(v Value, params asn1.fieldParameters) (ok bool)
func encoding/binary.dataSize(v Value) int
func encoding/json.addrMarshalerEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.addrTextMarshalerEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.boolEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.encodeByteSlice(e *json.encodeState, v Value, _ json.encOpts)
func encoding/json.indirect(v Value, decodingNull bool) (json.Unmarshaler, encoding.TextUnmarshaler, Value)
func encoding/json.intEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.interfaceEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.invalidValueEncoder(e *json.encodeState, v Value, _ json.encOpts)
func encoding/json.isEmptyValue(v Value) bool
func encoding/json.marshalerEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.stringEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.textMarshalerEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.uintEncoder(e *json.encodeState, v Value, opts json.encOpts)
func encoding/json.unsupportedTypeEncoder(e *json.encodeState, v Value, _ json.encOpts)
func encoding/json.valueEncoder(v Value) json.encoderFunc
func fmt.getField(v Value, i int) Value
func gitlab.com/pcanilho/goneo.asRef(val Value) Value
func internal/fmtsort.compare(aVal, bVal Value) int
func internal/fmtsort.nilCompare(aVal, bVal Value) (int, bool)
A ValueError occurs when a Value method is invoked on
a Value that does not support it. Such cases are documented
in the description of each method.
KindKindMethodstring(*T) Error() string
*T : error
A cacheKey is the key for use in the lookupCache.
Four values describe any of the types we are looking for:
type kind, one or two subtypes, and an extra integer.
extrauintptrkindKindt1*rtypet2*rtype
makeFuncImpl is the closure value implementing the function
returned by MakeFunc.
The first three words of this type must be kept in sync with
methodValue and runtime.reflectMethodValue.
Any changes should be reflected in all three.
// just args
codeuintptrfnfunc([]Value) []Valueftyp*funcType
// ptrmap for both args and results
func callReflect(ctxt *makeFuncImpl, frame unsafe.Pointer, retValid *bool)
Method on non-interface type
// fn used in interface call (one-word receiver)
// method type (without receiver)
// name of method
// fn used for normal method call
The first 3 words of this type must be kept in sync with
makeFuncImpl and runtime.reflectMethodValue.
Any changes should be reflected in all three.
// just args
fnuintptrmethodintrcvrValue
// ptrmap for both args and results
func callMethod(ctxt *methodValue, frame unsafe.Pointer, retValid *bool)
name is an encoded type name with optional extra data.
The first byte is a bit field containing:
1<<0 the name is exported
1<<1 tag data follows the name
1<<2 pkgPath nameOff follows the name and tag
The next two bytes are the data length:
l := uint16(data[1])<<8 | uint16(data[2])
Bytes [3:3+l] are the string data.
If tag data follows then bytes 3+l and 3+l+1 are the tag length,
with the data following.
If the import path follows, then 4 bytes at the end of
the data form a nameOff. The import path is only set for concrete
methods that are defined in a different package than their type.
If a name starts with "*", then the exported bit represents
whether the pointed to type is exported.
bytes*byte( T) data(off int, whySafe string) *byte( T) isExported() bool( T) name() (s string)( T) nameLen() int( T) pkgPath() string( T) tag() (s string)( T) tagLen() int
func newName(n, tag string, exported bool) name
func resolveReflectName(n name) nameOff
A runtimeSelect is a single case passed to rselect.
This must match ../runtime/select.go:/runtimeSelect
// channel
// SelectSend, SelectRecv or SelectDefault
// channel type
// ptr to data (SendDir) or ptr to receive buffer (RecvDir)
func rselect([]runtimeSelect) (chosen int, recvOK bool)
tflag is used by an rtype to signal what extra type information is
available in the memory directly following the rtype value.
tflag values must be kept in sync with copies in:
cmd/compile/internal/gc/reflect.go
cmd/link/internal/ld/decodesym.go
runtime/type.go
const tflagExtraStar
const tflagNamed
const tflagRegularMemory
const tflagUncommon
uncommonType is present only for defined types or types with methods
(if T is a defined type, the uncommonTypes for T and *T have methods).
Using a pointer to this struct reduces the overall size required
to describe a non-defined type with no methods.
// number of methods
// offset from this uncommontype to [mcount]method
// import path; empty for built-in types like int, string
// number of exported methods
(*T) exportedMethods() []method(*T) methods() []method
During deepValueEqual, must keep track of checks that are
in progress. The comparison algorithm assumes that all
checks in progress are true when it reencounters them.
Visited comparisons are stored in a map indexed by visit.
a1unsafe.Pointera2unsafe.PointertypType
func deepValueEqual(v1, v2 Value, visited map[visit]bool) bool
Package-Level Functions (total 131, in which 24 are exported)
Append appends the values x to a slice s and returns the resulting slice.
As in Go, each x's value must be assignable to the slice's element type.
AppendSlice appends a slice t to a slice s and returns the resulting slice.
The slices s and t must have the same element type.
ArrayOf returns the array type with the given count and element type.
For example, if t represents int, ArrayOf(5, t) represents [5]int.
If the resulting type would be larger than the available address space,
ArrayOf panics.
ChanOf returns the channel type with the given direction and element type.
For example, if t represents int, ChanOf(RecvDir, t) represents <-chan int.
The gc runtime imposes a limit of 64 kB on channel element types.
If t's size is equal to or exceeds this limit, ChanOf panics.
Copy copies the contents of src into dst until either
dst has been filled or src has been exhausted.
It returns the number of elements copied.
Dst and src each must have kind Slice or Array, and
dst and src must have the same element type.
As a special case, src can have kind String if the element type of dst is kind Uint8.
DeepEqual reports whether x and y are ``deeply equal,'' defined as follows.
Two values of identical type are deeply equal if one of the following cases applies.
Values of distinct types are never deeply equal.
Array values are deeply equal when their corresponding elements are deeply equal.
Struct values are deeply equal if their corresponding fields,
both exported and unexported, are deeply equal.
Func values are deeply equal if both are nil; otherwise they are not deeply equal.
Interface values are deeply equal if they hold deeply equal concrete values.
Map values are deeply equal when all of the following are true:
they are both nil or both non-nil, they have the same length,
and either they are the same map object or their corresponding keys
(matched using Go equality) map to deeply equal values.
Pointer values are deeply equal if they are equal using Go's == operator
or if they point to deeply equal values.
Slice values are deeply equal when all of the following are true:
they are both nil or both non-nil, they have the same length,
and either they point to the same initial entry of the same underlying array
(that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal.
Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil))
are not deeply equal.
Other values - numbers, bools, strings, and channels - are deeply equal
if they are equal using Go's == operator.
In general DeepEqual is a recursive relaxation of Go's == operator.
However, this idea is impossible to implement without some inconsistency.
Specifically, it is possible for a value to be unequal to itself,
either because it is of func type (uncomparable in general)
or because it is a floating-point NaN value (not equal to itself in floating-point comparison),
or because it is an array, struct, or interface containing
such a value.
On the other hand, pointer values are always equal to themselves,
even if they point at or contain such problematic values,
because they compare equal using Go's == operator, and that
is a sufficient condition to be deeply equal, regardless of content.
DeepEqual has been defined so that the same short-cut applies
to slices and maps: if x and y are the same slice or the same map,
they are deeply equal regardless of content.
As DeepEqual traverses the data values it may find a cycle. The
second and subsequent times that DeepEqual compares two pointer
values that have been compared before, it treats the values as
equal rather than examining the values to which they point.
This ensures that DeepEqual terminates.
FuncOf returns the function type with the given argument and result types.
For example if k represents int and e represents string,
FuncOf([]Type{k}, []Type{e}, false) represents func(int) string.
The variadic argument controls whether the function is variadic. FuncOf
panics if the in[len(in)-1] does not represent a slice and variadic is
true.
Indirect returns the value that v points to.
If v is a nil pointer, Indirect returns a zero Value.
If v is not a pointer, Indirect returns v.
MakeChan creates a new channel with the specified type and buffer size.
MakeFunc returns a new function of the given Type
that wraps the function fn. When called, that new function
does the following:
- converts its arguments to a slice of Values.
- runs results := fn(args).
- returns the results as a slice of Values, one per formal result.
The implementation fn can assume that the argument Value slice
has the number and type of arguments given by typ.
If typ describes a variadic function, the final Value is itself
a slice representing the variadic arguments, as in the
body of a variadic function. The result Value slice returned by fn
must have the number and type of results given by typ.
The Value.Call method allows the caller to invoke a typed function
in terms of Values; in contrast, MakeFunc allows the caller to implement
a typed function in terms of Values.
The Examples section of the documentation includes an illustration
of how to use MakeFunc to build a swap function for different types.
MakeMap creates a new map with the specified type.
MakeMapWithSize creates a new map with the specified type
and initial space for approximately n elements.
MakeSlice creates a new zero-initialized slice value
for the specified slice type, length, and capacity.
MapOf returns the map type with the given key and element types.
For example, if k represents int and e represents string,
MapOf(k, e) represents map[int]string.
If the key type is not a valid map key type (that is, if it does
not implement Go's == operator), MapOf panics.
New returns a Value representing a pointer to a new zero value
for the specified type. That is, the returned Value's Type is PtrTo(typ).
NewAt returns a Value representing a pointer to a value of the
specified type, using p as that pointer.
PtrTo returns the pointer type with element t.
For example, if t represents type Foo, PtrTo(t) represents *Foo.
Select executes a select operation described by the list of cases.
Like the Go select statement, it blocks until at least one of the cases
can proceed, makes a uniform pseudo-random choice,
and then executes that case. It returns the index of the chosen case
and, if that case was a receive operation, the value received and a
boolean indicating whether the value corresponds to a send on the channel
(as opposed to a zero value received because the channel is closed).
Select supports a maximum of 65536 cases.
SliceOf returns the slice type with element type t.
For example, if t represents int, SliceOf(t) represents []int.
StructOf returns the struct type containing fields.
The Offset and Index fields are ignored and computed as they would be
by the compiler.
StructOf currently does not generate wrapper methods for embedded
fields and panics if passed unexported StructFields.
These limitations may be lifted in a future version.
Swapper returns a function that swaps the elements in the provided
slice.
Swapper panics if the provided interface is not a slice.
TypeOf returns the reflection Type that represents the dynamic type of i.
If i is a nil interface value, TypeOf returns nil.
ValueOf returns a new Value initialized to the concrete value
stored in the interface i. ValueOf(nil) returns the zero Value.
Zero returns a Value representing the zero value for the specified type.
The result is different from the zero value of the Value struct,
which represents no value at all.
For example, Zero(TypeOf(42)) returns a Value with Kind Int and value 0.
The returned value is neither addressable nor settable.
add returns p+x.
The whySafe string is ignored, so that the function still inlines
as efficiently as p+x, but all call sites should use the string to
record why the addition is safe, which is to say why the addition
does not cause x to advance to the very end of p's allocation
and therefore point incorrectly at the next block in memory.
addReflectOff adds a pointer to the reflection lookup map in the runtime.
It returns a new ID that can be used as a typeOff or textOff, and will
be resolved correctly. Implemented in the runtime package.
arrayAt returns the i-th element of p,
an array whose elements are eltSize bytes wide.
The array pointed at by p must have at least i+1 elements:
it is invalid (but impossible to check here) to pass i >= len,
because then the result will point outside the array.
whySafe must explain why i < len. (Passing "i < len" is fine;
the benefit is to surface this assumption at the call site.)
call calls fn with a copy of the n argument bytes pointed at by arg.
After fn returns, reflectcall copies n-retoffset result bytes
back into arg+retoffset before returning. If copying result bytes back,
the caller must pass the argument frame type as argtype, so that
call can execute appropriate write barriers during the copy.
callMethod is the call implementation used by a function returned
by makeMethodValue (used by v.Method(i).Interface()).
It is a streamlined version of the usual reflect call: the caller has
already laid out the argument frame for us, so we don't have
to deal with individual Values for each argument.
It is in this file so that it can be next to the two similar functions above.
The remainder of the makeMethodValue implementation is in makefunc.go.
NOTE: This function must be marked as a "wrapper" in the generated code,
so that the linker can make it work correctly for panic and recover.
The gc compilers know to do that for the name "reflect.callMethod".
ctxt is the "closure" generated by makeVethodValue.
frame is a pointer to the arguments to that closure on the stack.
retValid points to a boolean which should be set when the results
section of frame is set.
callReflect is the call implementation used by a function
returned by MakeFunc. In many ways it is the opposite of the
method Value.call above. The method above converts a call using Values
into a call of a function with a concrete argument frame, while
callReflect converts a call of a function with a concrete argument
frame into a call using Values.
It is in this file so that it can be next to the call method above.
The remainder of the MakeFunc implementation is in makefunc.go.
NOTE: This function must be marked as a "wrapper" in the generated code,
so that the linker can make it work correctly for panic and recover.
The gc compilers know to do that for the name "reflect.callReflect".
ctxt is the "closure" generated by MakeFunc.
frame is a pointer to the arguments to that closure on the stack.
retValid points to a boolean which should be set when the results
section of frame is set.
convertOp returns the function to convert a value of type src
to a value of type dst. If the conversion is illegal, convertOp returns nil.
copyVal returns a Value containing the map key or value at ptr,
allocating a new variable as needed.
convertOp: []byte -> string
convertOp: complexXX -> complexXX
convertOp: direct copy
convertOp: floatXX -> floatXX
convertOp: floatXX -> intXX
convertOp: floatXX -> uintXX
convertOp: interface -> interface
convertOp: intXX -> [u]intXX
convertOp: intXX -> floatXX
convertOp: intXX -> string
convertOp: []rune -> string
convertOp: string -> []byte
convertOp: string -> []rune
convertOp: concrete -> interface
convertOp: uintXX -> [u]intXX
convertOp: uintXX -> floatXX
convertOp: uintXX -> string
Tests for deep equality using reflected types. The map argument tracks
comparisons that have already been seen, which allows short circuiting on
recursive types.
directlyAssignable reports whether a value x of type V can be directly
assigned (using memmove) to a value of type T.
https://golang.org/doc/go_spec.html#Assignability
Ignoring the interface rules (implemented elsewhere)
and the ideal constant rules (no ideal constants at run time).
emitGCMask writes the GC mask for [n]typ into out, starting at bit
offset base.
Dummy annotation marking that the value x escapes,
for use in cases where the reflect code is so clever that
the compiler cannot follow.
fnv1 incorporates the list of bytes into the hash x using the FNV-1 hash function.
funcLayout computes a struct type representing the layout of the
function arguments and return values for the function type t.
If rcvr != nil, rcvr specifies the type of the receiver.
The returned type exists only for GC, so we only fill out GC relevant info.
Currently, that's just size and the GC program. We also fill in
the name for possible debugging use.
funcName returns the name of f, for use in error messages.
funcStr builds a string representation of a funcType.
grow grows the slice s so that it can hold extra more values, allocating
more capacity if needed. It also returns the old and new slice lengths.
hashMightPanic reports whether the hash of a map key of type t might panic.
ifaceIndir reports whether t is stored indirectly in an interface value.
implements reports whether the type V implements the interface type T.
isLetter reports whether a given 'rune' is classified as a Letter.
isReflexive reports whether the == operation on the type is reflexive.
That is, x == x for all values x of type t.
isValidFieldName checks if a string is a valid (struct) field name or not.
According to the language spec, a field name should be an identifier.
identifier = letter { letter | unicode_digit } .
letter = unicode_letter | "_" .
makeComplex returns a Value of type t equal to v (possibly truncated to complex64),
where t is a complex64 or complex128 type.
makeFloat returns a Value of type t equal to v (possibly truncated to float32),
where t is a float32 or float64 type.
makeFloat returns a Value of type t equal to v, where t is a float32 type.
makeFuncStub is an assembly function that is the code half of
the function returned from MakeFunc. It expects a *callReflectFunc
as its context register, and its job is to invoke callReflect(ctxt, frame)
where ctxt is the context register and frame is a pointer to the first
word in the passed-in argument frame.
makeInt returns a Value of type t equal to bits (possibly truncated),
where t is a signed or unsigned int type.
makeMethodValue converts v from the rcvr+method index representation
of a method value to an actual method func value, which is
basically the receiver value with a special bit set, into a true
func value - a value holding an actual func. The output is
semantically equivalent to the input as far as the user of package
reflect can tell, but the true func representation can be handled
by code like Convert and Interface and Assign.
memmove copies size bytes to dst from src. No write barriers are used.
methodName returns the name of the calling method,
assumed to be two stack frames above.
methodNameSkip is like methodName, but skips another stack frame.
This is a separate function so that reflect.flag.mustBe will be inlined.
methodReceiver returns information about the receiver
described by v. The Value v may or may not have the
flagMethod bit set, so the kind cached in v.flag should
not be used.
The return value rcvrtype gives the method's actual receiver type.
The return value t gives the method type signature (without the receiver).
The return value fn is a pointer to the method code.
methodValueCall is an assembly function that is the code half of
the function returned from makeMethodValue. It expects a *methodValue
as its context register, and its job is to invoke callMethod(ctxt, frame)
where ctxt is the context register and frame is a pointer to the first
word in the passed-in argument frame.
needKeyUpdate reports whether map overwrites require the key to be copied.
resolveNameOff resolves a name offset from a base pointer.
The (*rtype).nameOff method is a convenience wrapper for this function.
Implemented in the runtime package.
resolveReflectName adds a name to the reflection lookup map in the runtime.
It returns a new nameOff that can be used to refer to the pointer.
resolveReflectText adds a function pointer to the reflection lookup map in
the runtime. It returns a new textOff that can be used to refer to the
pointer.
resolveReflectType adds a *rtype to the reflection lookup map in the runtime.
It returns a new typeOff that can be used to refer to the pointer.
resolveTextOff resolves a function pointer offset from a base type.
The (*rtype).textOff method is a convenience wrapper for this function.
Implemented in the runtime package.
resolveTypeOff resolves an *rtype offset from a base type.
The (*rtype).typeOff method is a convenience wrapper for this function.
Implemented in the runtime package.
rselect runs a select. It returns the index of the chosen case.
If the case was a receive, val is filled in with the received value.
The conventional OK bool indicates whether the receive corresponds
to a sent value.
runtimeStructField takes a StructField value passed to StructOf and
returns both the corresponding internal representation, of type
structField, and the pkgpath value to use for this field.
specialChannelAssignability reports whether a value x of channel type V
can be directly assigned (using memmove) to another channel type T.
https://golang.org/doc/go_spec.html#Assignability
T and V must be both of Chan kind.
v is a method receiver. Store at p the word which is used to
encode that receiver at the start of the argument list.
Reflect uses the "interface" calling convention for
methods, which always uses one word to record the receiver.
toType converts from a *rtype to a Type that can be returned
to the client of package reflect. In gc, the only concern is that
a nil *rtype must be replaced by a nil Type, but in gccgo this
function takes care of ensuring that multiple *rtype for the same
type are coalesced into a single Type.
typedmemclr zeros the value at ptr of type t.
typedmemclrpartial is like typedmemclr but assumes that
dst points off bytes into the value and only clears size bytes.
typedmemmove copies a value of type t to dst from src.
typedmemmovepartial is like typedmemmove but assumes that
dst and src point off bytes into the value and only copies size bytes.
typedslicecopy copies a slice of elemType values from src to dst,
returning the number of elements copied.
typelinks is implemented in package runtime.
It returns a slice of the sections in each module,
and a slice of *rtype offsets in each module.
The types in each module are sorted by string. That is, the first
two linked types of the first module are:
d0 := sections[0]
t1 := (*rtype)(add(d0, offset[0][0]))
t2 := (*rtype)(add(d0, offset[0][1]))
and
t1.String() < t2.String()
Note that strings are not unique identifiers for types:
there can be more than one with a given string.
Only types we might want to look up are included:
pointers, channels, maps, slices, and arrays.
typeptrdata returns the length in bytes of the prefix of t
containing pointer data. Anything after this offset is scalar data.
keep in sync with ../cmd/compile/internal/gc/reflect.go
typesByString returns the subslice of typelinks() whose elements have
the given string representation.
It may be empty (no known types with that string) or may have
multiple elements (multiple types with that string).
The funcLookupCache caches FuncOf lookups.
FuncOf does not share the common lookupCache since cacheKey is not
sufficient to represent functions unambiguously.
The lookupCache caches ArrayOf, ChanOf, MapOf and SliceOf lookups.
ptrMap is the cache for PtrTo.
The structLookupCache caches StructOf lookups.
StructOf does not share the common lookupCache since we need to pin
the memory associated with *structTypeFixedN.
Make sure these routines stay in sync with ../../runtime/map.go!
These types exist only for GC, so we only fill out GC relevant info.
Currently, that's just size and the GC program. We also fill in string
for possible debugging use.
Make sure these routines stay in sync with ../../runtime/map.go!
These types exist only for GC, so we only fill out GC relevant info.
Currently, that's just size and the GC program. We also fill in string
for possible debugging use.
See cmd/compile/internal/gc/reflect.go for derivation of constant.
Make sure these routines stay in sync with ../../runtime/map.go!
These types exist only for GC, so we only fill out GC relevant info.
Currently, that's just size and the GC program. We also fill in string
for possible debugging use.
must match declarations in runtime/map.go.
const ptrSize = 8 // unsafe.Sizeof(uintptr(0)) but an ideal const
tflagExtraStar means the name in the str field has an
extraneous '*' prefix. This is because for most types T in
a program, the type *T also exists and reusing the str data
saves binary size.
tflagNamed means the type has a name.
tflagRegularMemory means that equal and hash functions can treat
this type as a single region of t.size bytes.
tflagUncommon means that there is a pointer, *uncommonType,
just beyond the outer type structure.
For example, if t.Kind() == Struct and t.tflag&tflagUncommon != 0,
then t has uncommonType data and it can be accessed as:
type tUncommon struct {
structType
u uncommonType
}
u := &(*tUncommon)(unsafe.Pointer(t)).u
The pages are generated with Goldsv0.4.2. (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.
