package reflect2

import (
	
	
)

type UnsafeArrayType struct {
	unsafeType
	elemRType  unsafe.Pointer
	pElemRType unsafe.Pointer
	elemSize   uintptr
	likePtr    bool
}

func newUnsafeArrayType( *frozenConfig,  reflect.Type) *UnsafeArrayType {
	return &UnsafeArrayType{
		unsafeType: *newUnsafeType(, ),
		elemRType:  unpackEFace(.Elem()).data,
		pElemRType: unpackEFace(reflect.PtrTo(.Elem())).data,
		elemSize:   .Elem().Size(),
		likePtr:    likePtrType(),
	}
}

func ( *UnsafeArrayType) () bool {
	return .likePtr
}

func ( *UnsafeArrayType) ( interface{}) interface{} {
	 := unpackEFace()
	assertType("Type.Indirect argument 1", .ptrRType, .rtype)
	return .UnsafeIndirect(.data)
}

func ( *UnsafeArrayType) ( unsafe.Pointer) interface{} {
	if .likePtr {
		return packEFace(.rtype, *(*unsafe.Pointer)())
	}
	return packEFace(.rtype, )
}

func ( *UnsafeArrayType) ( interface{},  int,  interface{}) {
	 := unpackEFace()
	assertType("ArrayType.SetIndex argument 1", .ptrRType, .rtype)
	 := unpackEFace()
	assertType("ArrayType.SetIndex argument 3", .pElemRType, .rtype)
	.UnsafeSetIndex(.data, , .data)
}

func ( *UnsafeArrayType) ( unsafe.Pointer,  int,  unsafe.Pointer) {
	 := arrayAt(, , .elemSize, "i < s.Len")
	typedmemmove(.elemRType, , )
}

func ( *UnsafeArrayType) ( interface{},  int) interface{} {
	 := unpackEFace()
	assertType("ArrayType.GetIndex argument 1", .ptrRType, .rtype)
	 := .UnsafeGetIndex(.data, )
	return packEFace(.pElemRType, )
}

func ( *UnsafeArrayType) ( unsafe.Pointer,  int) unsafe.Pointer {
	return arrayAt(, , .elemSize, "i < s.Len")
}