Golang SliceHeader.Data方法代码示例

func (repo *Repository) ListBranches(flags ...BranchType) ([]string, error) {
	var cnames C.git_strarray
	defer C.git_strarray_free(&cnames)
	var cflags C.uint
	if len(flags) == 0 {
		cflags = C.uint(BRANCH_ALL)
	} else {
		for _, flag := range flags {
			cflags |= C.uint(flag)
		}
	}
	ecode := C.git_branch_list(&cnames, repo.git_repository, cflags)
	if ecode != git_SUCCESS {
		return nil, gitError()
	}

	// TODO: Find a safer way if one exists.
	var namesSlice reflect.SliceHeader
	length := int(cnames.count)
	namesSlice.Data = uintptr(unsafe.Pointer(cnames.strings))
	namesSlice.Len = length
	namesSlice.Cap = length
	cnameStrings := *(*[]*C.char)(unsafe.Pointer(&namesSlice))

	names := make([]string, length)
	for i := 0; i < len(cnameStrings); i++ {
		names[i] = C.GoString(cnameStrings[i])
	}

	return names, nil
}

func slice() {
	fmt.Printf("Slice:\n")

	var a [10]byte

	// reflect.SliceHeader is a runtime representation of the internal workings
	// of a slice. To make it point to a specific address, use something like
	// the following:
	//    h.Data = uintptr(0x100)
	// And replace '0x100' with the desired address.
	var h reflect.SliceHeader
	h.Data = uintptr(unsafe.Pointer(&a)) // The address of the first element of the underlying array.
	h.Len = len(a)
	h.Cap = len(a)

	// Create an actual slice from the SliceHeader.
	s := *(*[]byte)(unsafe.Pointer(&h))

	fmt.Printf("Before:\n\ts: %v\n\ta: %v\n", s, a)

	// Copy a string into the slice. This fills the underlying array, which in
	// this case has been manually set to 'a'.
	copy(s, "A string.")

	fmt.Printf("After:\n\ts: %v\n\ta: %v\n", s, a)
}

func (repo *Repository) TagListMatch(pattern string) ([]string, error) {
	cpattern := C.CString(pattern)
	defer C.free(unsafe.Pointer(cpattern))
	var ctags C.git_strarray
	defer C.git_strarray_free(&ctags)
	ecode := C.git_tag_list_match(&ctags, cpattern, repo.git_repository)
	if ecode != git_SUCCESS {
		return nil, gitError()
	}

	// TODO: Find a safer way if one exists.
	var tagsSlice reflect.SliceHeader
	length := int(ctags.count)
	tagsSlice.Data = uintptr(unsafe.Pointer(ctags.strings))
	tagsSlice.Len = length
	tagsSlice.Cap = length
	ctagStrings := *(*[]*C.char)(unsafe.Pointer(&tagsSlice))

	tags := make([]string, length)
	for i := 0; i < len(ctagStrings); i++ {
		tags[i] = C.GoString(ctagStrings[i])
	}

	return tags, nil
}

func GetKeyboardState() []uint8 {
	var numkeys C.int
	start := C.SDL_GetKeyboardState(&numkeys)
	sh := reflect.SliceHeader{}
	sh.Len = int(numkeys)
	sh.Cap = int(numkeys)
	sh.Data = uintptr(unsafe.Pointer(start))
	return *(*[]uint8)(unsafe.Pointer(&sh))
}

func init() {
	data := new(reflect.SliceHeader)
	data.Cap = 10
	data.Len = 10
	data.Data = uintptr(C.calloc(1, C.size_t(unsafe.Sizeof(SomeStruct{}))))

	someData = *(*[]SomeStruct)(unsafe.Pointer(data))

	for i := 0; i < len(someData); i++ {
		someData[i] = SomeStruct{
			Id:   i,
			Name: "你好" + strconv.Itoa(i),
		}
	}
}

func (repo *Repository) ListReferences(flags RefType) ([]string, error) {
	var crefs C.git_strarray
	defer C.git_strarray_free(&crefs)
	ecode := C.git_reference_list(&crefs, repo.git_repository, C.uint(flags))
	if ecode != git_SUCCESS {
		return nil, gitError()
	}

	// TODO: Find a safer way if one exists.
	var refsSlice reflect.SliceHeader
	length := int(crefs.count)
	refsSlice.Data = uintptr(unsafe.Pointer(crefs.strings))
	refsSlice.Len = length
	refsSlice.Cap = length
	crefStrings := *(*[]*C.char)(unsafe.Pointer(&refsSlice))

	refs := make([]string, length)
	for i := 0; i < len(crefStrings); i++ {
		refs[i] = C.GoString(crefStrings[i])
	}
	return refs, nil
}

func (repo *Repository) GetManyAttrs(path string, names []string, flags ...AttrFlag) ([]string, error) {
	var values [1]int8
	cvalues := (*C.char)(&values[0])
	cpath := C.CString(path)
	defer C.free(unsafe.Pointer(cpath))

	length := len(names)
	clength := C.size_t(length)
	cnames := make([]*C.char, length)
	for i := 0; i < length; i++ {
		cnames[i] = C.CString(names[i])
		defer C.free(unsafe.Pointer(cnames[i]))
	}

	var cflags C.uint32_t
	for _, flag := range flags {
		cflags |= C.uint32_t(flag)
	}

	ecode := C.git_attr_get_many(&cvalues, repo.git_repository, cflags, cpath, clength, &cnames[0])
	if ecode != git_SUCCESS {
		return nil, gitError()
	}

	// TODO: Find a safer way if one exists.
	var valuesSlice reflect.SliceHeader
	valuesSlice.Data = uintptr(unsafe.Pointer(cvalues))
	valuesSlice.Len = length
	valuesSlice.Cap = length
	cvalueStrings := *(*[]*C.char)(unsafe.Pointer(&valuesSlice))

	valuesOut := make([]string, length)
	for i := 0; i < length; i++ {
		valuesOut[i] = C.GoString(cvalueStrings[i])
	}

	return valuesOut, nil
}

func main() {
	data1 := initTestData()

	checkTestData(len(data1), data1)

	itemSize := unsafe.Sizeof(BigStruct{})

	csize := C.size_t(itemSize * uintptr(len(data1)))

	t1 := time.Now().Nanosecond()

	mem := C.malloc(csize)

	C.memcpy(mem, unsafe.Pointer((*reflect.SliceHeader)(unsafe.Pointer(&data1)).Data), csize)

	t2 := time.Now().Nanosecond()

	println("Go to C:", (t2-t1)/int(time.Microsecond))

	data2 := new(reflect.SliceHeader)
	data2.Cap = len(data1)
	data2.Len = len(data1)
	data2.Data = uintptr(mem)

	checkTestData(len(data1), *(*[]BigStruct)(unsafe.Pointer(data2)))

	t3 := time.Now().Nanosecond()

	data3 := make([]BigStruct, len(data1))
	copy(data3, *(*[]BigStruct)(unsafe.Pointer(data2)))

	t4 := time.Now().Nanosecond()

	checkTestData(len(data1), data3)

	println("C to Go:", (t4-t3)/int(time.Microsecond))
}

func main() {
	var a []byte
	var e []byte
	var r reflect.SliceHeader
	fmt.Println("A", A)
	a = A[2:10]
	fmt.Println("a.cap", cap(a))
	fmt.Println("a", a)
	d := (unsafe.Pointer(&A))
	fmt.Println("d", d)
	r.Data = uintptr(unsafe.Pointer(&A))
	r.Len = 4
	r.Cap = 10
	e = *(*[]byte)(unsafe.Pointer(&r))
	//e = a
	fmt.Println("e", e)
	var rec Rec
	f := unsafe.Sizeof(rec)
	fmt.Println("sizeof rec", f)
	/*
		fmt.Println("A", A)
		a := A[2:10]
		fmt.Println("a", a)
		b := unsafe.Pointer(&A)
		fmt.Println("b", b)
		c := unsafe.Pointer(&a)
		fmt.Println("c", c)
		d := (*[2]Rec)(unsafe.Pointer(&a[2]))
		fmt.Println("d", d)
		head := (* Head)(unsafe.Pointer(&A))
		fmt.Println("head", head)
		fmt.Println("*head", *head)
		fmt.Println(unsafe.Sizeof(I))
		fmt.Println(unsafe.Sizeof(leafhead))
		fmt.Println(sizeHead)
	*/
}

func NewFromFile(filename string) (*Continuum, error) {
	var cont C.ketama_continuum
	fn := C.CString(filename)
	defer C.free(unsafe.Pointer(fn))
	rv := C.ketama_roll(&cont, fn)
	if rv == 0 {
		errMsg := C.GoString(C.ketama_error())
		return nil, errors.New(errMsg)
	}

	addrMap := make(map[string]net.Addr)

	var mcsSlice reflect.SliceHeader
	mcsSlice.Data = uintptr(cont.array)
	mcsSlice.Len = int(cont.numpoints)
	mcsSlice.Cap = int(cont.numpoints)
	mcss := *(*[]C.mcs)(unsafe.Pointer(&mcsSlice))
	for _, mcs := range mcss {
		ip := C.GoString(C.get_ip(&mcs))
		addrMap[ip], _ = getServerAddr(ip)
	}

	return &Continuum{&cont, addrMap}, nil
}

func setSlice(s *reflect.SliceHeader, data uintptr, n int) {
	s.Data = data
	s.Len = n
	s.Cap = n
}

func setupSlice(hdr *reflect.SliceHeader, ptr unsafe.Pointer, size C.size_t) {
	hdr.Cap = int(size)
	hdr.Len = int(size)
	hdr.Data = uintptr(ptr)
}

func newRawSliceHeader(sh *reflect.SliceHeader, b []byte, stride int) *reflect.SliceHeader {
	sh.Len = len(b) / stride
	sh.Cap = len(b) / stride
	sh.Data = (uintptr)(unsafe.Pointer(&b[0]))
	return sh
}