reflecti

package
v1.3.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 13, 2023 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	NoError           = "NoError"
	JsonError         = "JsonError"
	MethodNotFound    = "MethodNotFound"
	ParameterNotMatch = "ParameterNotMatch"
)

Variables

View Source 
var (
	PtrOffset = func() uintptr {
		return unsafe.Offsetof(e.Word)
	}()
	KindOffset = func() uintptr {
		return unsafe.Offsetof(e.Typ.Kind)
	}()
	ElemOffset = func() uintptr {
		return unsafe.Offsetof(new(PtrType).Elem)
	}()
	SliceDataOffset = func() uintptr {
		return unsafe.Offsetof(new(reflect.SliceHeader).Data)
	}()
)
View Source 
var ConverterArrays = []Converter{
	reflect.Bool:    convertBool,
	reflect.Int:     convertInt,
	reflect.Int8:    convertInt8,
	reflect.Int16:   convertInt16,
	reflect.Int32:   convertInt32,
	reflect.Int64:   convertInt64,
	reflect.Uint:    convertUint,
	reflect.Uint8:   convertUint8,
	reflect.Uint16:  convertUint16,
	reflect.Uint32:  convertUint32,
	reflect.Uint64:  convertUint64,
	reflect.Float32: convertFloat32,
	reflect.Float64: convertFloat64,
	reflect.String:  convertString,
}

Functions

func AnyConvert added in v1.1.0 

func AnyConvert[T any](v any) T

func ContainType 

func ContainType()

TODO:

func ConvertInt64 added in v1.1.0 

func ConvertInt64(v interface{}) int64

func CopyFieldValueByType added in v1.1.0 

func CopyFieldValueByType(src any, sub any) bool

CopyFieldValueByType 根据类型复制字段 参数均为指针,sub类型为src field的类型

func CopyStruct added in v1.1.0 

func CopyStruct(src any, dest any) error

Copy 复制结构体,浅表复制

func DereferenceInterfaceValue 

func DereferenceInterfaceValue(v reflect.Value) reflect.Value

DereferenceInterfaceValue returns the value of the underlying type that implements the interface v.

func DereferencePtrValue 

func DereferencePtrValue(v reflect.Value) reflect.Value

DereferencePtrValue returns the underlying non-pointer type value.

func DereferenceType 

func DereferenceType(t reflect.Type) reflect.Type

func DereferenceValue 

func DereferenceValue(v reflect.Value) reflect.Value

DereferenceValue dereference and unpack interface, get the underlying non-pointer and non-interface value.

func Hash 

func Hash(v interface{}) uint32

func InvokeByValues 

func InvokeByValues(method reflect.Value, params []reflect.Value) []any

func OriginalType 

func OriginalType(typ reflect.Type) reflect.Type

获取引用类型的原始类型

func RuntimeTypeID 

func RuntimeTypeID(t reflect.Type) uintptr

func SetField 

func SetField(structValue reflect.Value, name string, value any) error

func SetField2 added in v1.1.0 

func SetField2(o interface{}, field string, v interface{})

func SetFieldByString added in v1.1.0 

func SetFieldByString(value string, field reflect.Value) error

func SetStructFieldByString added in v1.1.0 

func SetStructFieldByString(field, value string, dst any) error

func SetSubField added in v1.1.0 

func SetSubField(src any, sub any) bool

SetSubField 设置字段值 参数均为指针,dst类型为src field的类型

func SetSubFieldValue added in v1.1.0 

func SetSubFieldValue(srcValue reflect.Value, subValue reflect.Value) bool

SetSubFieldValue 设置字段值 subValue为srcValue field的类型

func String added in v1.1.0 

func String(value reflect.Value) string

func StringConvert added in v1.1.0 

func StringConvert(value string, kind reflect.Kind) (any, error)

func TypeInfo 

func TypeInfo(v interface{})

Types

type ChanType 

type ChanType struct {
	Rtype
	Elem *Rtype  // channel element type
	Dir  uintptr // channel direction (ChanDir)
}

ChanType represents a channel type.

type Converter 

type Converter func(string) any

type Eface 

type Eface struct {
	Type *Type
	Data unsafe.Pointer
}

type EmptyInterface 

type EmptyInterface struct {
	Typ  *Rtype
	Word unsafe.Pointer
}

type Flag 

type Flag uintptr
const (
	FlagKindWidth        = 5 // there are 27 kinds
	FlagKindMask    Flag = 1<<FlagKindWidth - 1
	FlagStickyRO    Flag = 1 << 5
	FlagEmbedRO     Flag = 1 << 6
	FlagIndir       Flag = 1 << 7
	FlagAddr        Flag = 1 << 8
	FlagMethod      Flag = 1 << 9
	FlagMethodShift      = 10
	FlagRO          Flag = FlagStickyRO | FlagEmbedRO
)

type Func 

type Func struct {
	Entry   uintptr // start pc
	Nameoff int32   // function name

	Args        int32  // in/out args size
	Deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any.

	Pcsp     uint32
	Pcfile   uint32
	Pcln     uint32
	Npcdata  uint32
	CuOffset uint32 // runtime.cutab offset of this function's CU
	FuncID   FuncID // set for certain special runtime functions

	Nfuncdata uint8 // must be last
	// contains filtered or unexported fields
}

type FuncID 

type FuncID uint8

type Iface 

type Iface struct {
	Itab *Itab
	Data unsafe.Pointer
}

type Imethod 

type Imethod struct {
	Name NameOff // name of method
	Typ  TypeOff // .(*FuncType) underneath
}

imethod represents a method on an interface type

type InterfaceType 

type InterfaceType struct {
	Rtype
	PkgPath Name      // import path
	Methods []Imethod // sorted by hash
}

interfaceType represents an interface type.

type Itab 

type Itab struct {
	Inter  *InterfaceType
	Type   *Type
	Link   *Itab
	Hash   uint32 // copy of _type.hash. Used for type switches.
	Bad    bool   // type does not implement interface
	Inhash bool   // has this Itab been added to hash?
	Unused [2]byte
	Fun    [1]uintptr // variable sized
}

type MapType 

type MapType struct {
	Rtype
	Key    *Rtype // map key type
	Elem   *Rtype // map element (value) type
	Bucket *Rtype // internal bucket structure
	// function for hashing keys (ptr to key, seed) -> hash
	Hasher     func(unsafe.Pointer, uintptr) uintptr
	Keysize    uint8  // size of key slot
	Valuesize  uint8  // size of value slot
	Bucketsize uint16 // size of bucket
	Flags      uint32
}

MapType represents a map type.

type Name 

type Name struct {
	Bytes *byte
}

type NameOff 

type NameOff int32 // offset to a name

type NonEmptyInterface 

type NonEmptyInterface struct {
	// see ../runtime/iface.go:/Itab
	Itab *struct {
		Ityp *Rtype // static interface type
		Typ  *Rtype // dynamic concrete type
		Hash uint32 // copy of typ.hash

		Fun [100000]unsafe.Pointer // method table
		// contains filtered or unexported fields
	}
	Word unsafe.Pointer
}

NonEmptyInterface is the header for an interface value with methods.

type PtrType 

type PtrType struct {
	Rtype
	Elem *Rtype // pointer element (pointed at) type
}

PtrType represents a pointer type.

type ReflectInvoker 

type ReflectInvoker struct {
	Methods map[string]reflect.Value
}

func NewReflectInvoker added in v1.1.0 

func NewReflectInvoker() *ReflectInvoker

func (*ReflectInvoker) InvokeByInterfaceArgs 

func (r *ReflectInvoker) InvokeByInterfaceArgs(funcName string, Params []interface{}) []reflect.Value

func (*ReflectInvoker) InvokeByJson 

func (r *ReflectInvoker) InvokeByJson(byteData []byte) []byte

func (*ReflectInvoker) InvokeByReflectArgs 

func (r *ReflectInvoker) InvokeByReflectArgs(funcName string, par []reflect.Value) []reflect.Value

func (*ReflectInvoker) RegisterMethod 

func (r *ReflectInvoker) RegisterMethod(v interface{})

type Request 

type Request struct {
	FuncName string        `json:"funcName"`
	Params   []interface{} `json:"params"`
}

type Response 

type Response struct {
	FuncName string        `json:"funcName"`
	Result   []interface{} `json:"result"`
	ErrorMsg string        `json:"errorMsg"`
}

type Rtype 

type Rtype struct {
	Size    uintptr
	Ptrdata uintptr // number of bytes in the type that can contain pointers
	Hash    uint32  // hash of type; avoids computation in hash tables

	Align      uint8 // alignment of variable with this type
	FieldAlign uint8 // alignment of struct field with this type
	Kind       uint8 // enumeration for C
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	Equal     func(unsafe.Pointer, unsafe.Pointer) bool
	Gcdata    *byte   // garbage collection data
	Str       NameOff // string form
	PtrToThis TypeOff // type for pointer to this type, may be zero
	// contains filtered or unexported fields
}

Rtype must be kept in sync with ../runtime/type.go:/^type._type.

func RtypeOff 

func RtypeOff(section unsafe.Pointer, off int32) *Rtype

type SliceType 

type SliceType struct {
	Rtype
	Elem *Rtype // Slice element type
}

SliceType represents a Slice type.

type StructField 

type StructField struct {
	Name        Name    // name is always non-empty
	Typ         *Rtype  // type of field
	OffsetEmbed uintptr // byte offset of field<<1 | isEmbedded
}

Struct field

type StructType 

type StructType struct {
	Rtype
	PkgPath Name
	Fields  []StructField // sorted by offset
}

StructType represents a struct type.

type TextOff 

type TextOff int32 // offset from top of text section

type Tflag 

type Tflag uint8

type Type 

type Type struct {
	Size       uintptr
	Ptrdata    uintptr // size of memory prefix holding all pointers
	Hash       uint32
	Tflag      Tflag
	Align      uint8
	FieldAlign uint8
	Kind       uint8
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	Equal func(unsafe.Pointer, unsafe.Pointer) bool
	// gcdata stores the GC type data for the garbage collector.
	// If the KindGCProg bit is set in kind, gcdata is a GC program.
	// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
	Gcdata    *byte
	Str       NameOff
	PtrToThis TypeOff
}

type TypeOff 

type TypeOff int32 // offset to an *Rtype

type Value 

type Value struct {
	Typ *Rtype
	Ptr unsafe.Pointer
	Flag
}

func ConvertValue 

func ConvertValue(v reflect.Value) Value

func ValueOf 

func ValueOf(v interface{}) Value

func (Value) Kind 

func (v Value) Kind() reflect.Kind

Kind gets the reflect.Kind fastly.

func (Value) Pointer 

func (v Value) Pointer() uintptr

Pointer gets the pointer of i. NOTE: 

*T and T, gets diffrent pointer

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.