field.go

package xunsafe

import (
	"reflect"
	"unsafe"
)

//ptrKind defines generic ptr handling kind
type ptrKind byte

const (
	ptrKindEmptyInterface = ptrKind(iota)
	ptrKindInterface
	ptrKindMethodInterface
)

//Field represents a field
type Field struct {
	Name string
	reflect.Type
	Tag       reflect.StructTag
	Anonymous bool
	Offset    uintptr
	Index     uint16
	kind      reflect.Kind
	rtype     *rtype
	rtypPtr   *rtype
	ptrKind
}

//Pointer return  field pointer (structPtr + field.Offset)
func (f *Field) Pointer(structPtr unsafe.Pointer) unsafe.Pointer {
	return unsafe.Pointer(uintptr(structPtr) + f.Offset)
}

//IsNil returns nil if structPtr is nil or field value is nil
func (f *Field) IsNil(structPtr unsafe.Pointer) bool {
	if structPtr == nil {
		return true
	}
	return *(*unsafe.Pointer)(f.Pointer(structPtr)) == nil
}

//ValuePointer return pointer to T, if value is as *T, this method would dereference it
func (f *Field) ValuePointer(structPtr unsafe.Pointer) unsafe.Pointer {
	ret := unsafe.Pointer(uintptr(structPtr) + f.Offset)
	if f.kind == reflect.Ptr {
		ret = DerefPointer(ret)
	}
	return ret
}

//SafePointer returns field pointer, if field pointer is a pointer this method initialises that pointer
func (f *Field) SafePointer(structPtr unsafe.Pointer, target reflect.Type) unsafe.Pointer {
	fieldPtr := f.Pointer(structPtr)
	if f.kind == reflect.Ptr {
		itemPtr := (*unsafe.Pointer)(fieldPtr)
		if *itemPtr != nil {
			return fieldPtr
		}
		EnsureAddressPointer(fieldPtr, f.Type)
	}
	return fieldPtr
}

//EnsurePointer initialises field type pointer if needed, and return filed type value pointer rather field pointer.
//for example if field is of T type this method returns *T, in case field is of *T, this method
//also return *T, if you need always field pointer use Field.Pointer method
func (f *Field) EnsurePointer(structPtr unsafe.Pointer) unsafe.Pointer {
	addr := f.Pointer(structPtr)
	ptr := (*unsafe.Pointer)(addr)
	if f.kind != reflect.Ptr {
		return addr
	}
	if *ptr == nil {
		var newPointer unsafe.Pointer
		*ptr = unsafe.Pointer(&newPointer)
	}
	return *ptr
}

func (f *Field) initType() {
	fType := f.Type
	f.ptrKind = ptrKindEmptyInterface
	if f.Type.Kind() == reflect.Interface {
		if f.Type.NumMethod() == 0 {
			f.ptrKind = ptrKindInterface
		} else {
			f.ptrKind = ptrKindMethodInterface
		}
	}
	ptrValue := reflect.New(fType)
	ptrElemValue := ptrValue.Elem()
	valPtr := ptrValue.Interface()
	val := ptrElemValue.Interface()
	f.rtypPtr = ((*emptyInterface)(unsafe.Pointer(&valPtr))).typ
	f.rtype = ((*emptyInterface)(unsafe.Pointer(&val))).typ
}

//NewField creates a new filed
func NewField(field reflect.StructField) *Field {
	fieldType := field.Type
	f := &Field{
		Name:      field.Name,
		Type:      fieldType,
		Tag:       field.Tag,
		Anonymous: field.Anonymous,
		Offset:    field.Offset,
		kind:      fieldType.Kind(),
	}
	if len(field.Index) > 0 {
		f.Index = uint16(field.Index[0])
	}
	f.initType()
	return f
}

//FieldByIndex creates a field for supplied struct type and field indexAddr
func FieldByIndex(structType reflect.Type, index int) *Field {
	return NewField(structType.Field(index))
}

//FieldByName creates a field for supplied struct type and field name
func FieldByName(structType reflect.Type, name string) *Field {
	switch structType.Kind() {
	case reflect.Ptr:
		return FieldByName(structType.Elem(), name)
	case reflect.Slice:
		return FieldByName(structType.Elem(), name)
	}
	structField, ok := structType.FieldByName(name)
	if !ok {
		return nil
	}
	return NewField(structField)
}