// JByteArray converts the provided Go byte slice into a Java byte array.
func JByteArray(env Env, bytes []byte) (Object, error) {
arr := C.NewByteArray(env.value(), C.jsize(len(bytes)))
if len(bytes) > 0 {
C.SetByteArrayRegion(env.value(), arr, 0, C.jsize(len(bytes)), (*C.jbyte)(unsafe.Pointer(&bytes[0])))
if err := JExceptionMsg(env); err != nil {
return NullObject, err
}
}
return Object(uintptr(unsafe.Pointer(arr))), nil
}
// JObjectArray converts the provided slice of objects into a Java object
// array of the provided element type.
func JObjectArray(env Env, arr []Object, elemClass Class) (Object, error) {
arrObj := C.NewObjectArray(env.value(), C.jsize(len(arr)), elemClass.value(), nil)
for i, elem := range arr {
C.SetObjectArrayElement(env.value(), arrObj, C.jsize(i), elem.value())
if err := JExceptionMsg(env); err != nil {
return NullObject, err
}
}
return Object(uintptr(unsafe.Pointer(arrObj))), nil
}
func (self *Environment) newByteObject(bts []byte) (o *Object, err error) {
ja := C.envNewByteArray(self.env, C.jsize(len(bts)))
if ja == nil {
err = errors.New("Error allocating byte array")
}
if err == nil && len(bts) > 0 {
bptr := make([]byte, len(bts))
copy(bptr, bts)
//log.Printf("bptr: %s %p %p", bptr,bptr, &bptr[0] )
C.envSetByteArrayRegion(self.env, ja, 0, C.jsize(len(bptr)), unsafe.Pointer(&bptr[0]))
}
if err == nil {
o = newObject(C.jobject(ja))
}
return
}
func (self *Environment) newObjectArray(sz int, klass *Class, init C.jobject) (o *Object, err error) {
ja := C.envNewObjectArray(self.env, C.jsize(sz), klass.class, init)
if ja == nil {
err = self.ExceptionOccurred()
}
if err == nil {
o = newObject(C.jobject(ja))
}
return
}
func (self *Environment) ToObjectArray(arrayObj *Object) []*Object {
var glen int
if arrayObj.object == nil {
glen = 0
} else {
jlen := C.envGetArrayLength(self.env, arrayObj.object)
glen = int(jlen)
}
objs := make([]*Object, glen)
for i := 0; i < glen; i++ {
objs[i] = &Object{C.envGetObjectArrayElement(self.env, arrayObj.object, C.jsize(i))}
}
return objs
}
func (self *Environment) setObjectArrayElement(arr *Object, pos int, item *Object) (err error) {
C.envSetObjectArrayElement(self.env, arr.object, C.jsize(pos), item.object)
return
}
// GoObjectArray converts a Java object array to a Go slice of Java objects.
func GoObjectArray(env Env, arr Object) ([]Object, error) {
if arr.IsNull() {
return nil, nil
}
length := int(C.GetArrayLength(env.value(), C.jarray(arr.value())))
ret := make([]Object, length)
for i := 0; i < length; i++ {
ret[i] = Object(uintptr(unsafe.Pointer(C.GetObjectArrayElement(env.value(), C.jobjectArray(arr.value()), C.jsize(i)))))
if err := JExceptionMsg(env); err != nil {
// Out-of-bounds index.
return nil, err
}
}
return ret, nil
}
