func doFinish(goRef C.jlong, numResults int) (jutil.Object, error) {
// Have all the results be decoded into *vdl.Value.
resultPtrs := make([]interface{}, numResults)
for i := 0; i < numResults; i++ {
value := new(vdl.Value)
resultPtrs[i] = &value
}
if err := (*(*rpc.ClientCall)(jutil.GoRefValue(jutil.Ref(goRef)))).Finish(resultPtrs...); err != nil {
// Invocation error.
return jutil.NullObject, err
}
// VOM-encode the results.
vomResults := make([][]byte, numResults)
for i, resultPtr := range resultPtrs {
// Remove the pointer from the result. Simply *resultPtr doesn't work
// as resultPtr is of type interface{}.
result := interface{}(jutil.DerefOrDie(resultPtr))
var err error
if vomResults[i], err = vom.Encode(result); err != nil {
return jutil.NullObject, err
}
}
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jArr, err := jutil.JByteArrayArray(env, vomResults)
if err != nil {
return jutil.NullObject, err
}
// Must grab a global reference as we free up the env and all local references that come along
// with it.
return jutil.NewGlobalRef(env, jArr), nil // Un-refed in DoAsyncCall
}
// JVomCopyWithType copies the provided Go value into a Java object of the
// given type, by encoding/decoding it from VOM.
func JVomCopyWithType(env Env, val interface{}, typeObj Object) (Object, error) {
data, err := vom.Encode(val)
if err != nil {
return NullObject, err
}
return JVomDecodeWithType(env, data, typeObj)
}
//export Java_io_v_impl_google_rpc_StreamImpl_nativeRecv
func Java_io_v_impl_google_rpc_StreamImpl_nativeRecv(jenv *C.JNIEnv, jStream C.jobject, goRef C.jlong, jCallbackObj C.jobject) {
env := jutil.Env(uintptr(unsafe.Pointer(jenv)))
jCallback := jutil.Object(uintptr(unsafe.Pointer(jCallbackObj)))
result := new(vdl.Value)
jutil.DoAsyncCall(env, jCallback, func() (jutil.Object, error) {
if err := (*(*rpc.Stream)(jutil.GoRefValue(jutil.Ref(goRef)))).Recv(&result); err != nil {
if err == io.EOF {
// Java uses EndOfFile error to detect EOF.
err = verror.NewErrEndOfFile(nil)
}
return jutil.NullObject, err
}
vomResult, err := vom.Encode(result)
if err != nil {
return jutil.NullObject, err
}
env, freeFunc := jutil.GetEnv()
defer freeFunc()
jResult, err := jutil.JByteArray(env, vomResult)
if err != nil {
return jutil.NullObject, err
}
// Must grab a global reference as we free up the env and all local references that come along
// with it.
return jutil.NewGlobalRef(env, jResult), nil // Un-refed in DoAsyncCall
})
}
// VomCopy copies the provided Go value by encoding/decoding it from VOM.
func VomCopy(src interface{}, dstptr interface{}) error {
data, err := vom.Encode(src)
if err != nil {
return err
}
return vom.Decode(data, dstptr)
}
func vomBytesCustomer() []byte {
data, err := vom.Encode(vdlCustomer)
if err != nil {
panic(err)
}
return data
}
// JavaSignature converts the provided Go Signature into a Java VSignature.
func JavaSignature(env jutil.Env, sig security.Signature) (jutil.Object, error) {
encoded, err := vom.Encode(sig)
if err != nil {
return jutil.NullObject, err
}
jSignature, err := jutil.CallStaticObjectMethod(env, jUtilClass, "decodeSignature", []jutil.Sign{jutil.ByteArraySign}, signatureSign, encoded)
if err != nil {
return jutil.NullObject, err
}
return jSignature, nil
}
func doFinish(call rpc.ClientCall, numResults int) (C.SwiftByteArrayArray, error) {
// Have all the results be decoded into *vdl.Value.
resultPtrs := make([]interface{}, numResults)
for i := 0; i < numResults; i++ {
value := new(vdl.Value)
resultPtrs[i] = &value
}
if err := call.Finish(resultPtrs...); err != nil {
// Invocation error.
return EmptySwiftByteArrayArray(), err
}
// VOM-encode the results. Note in the future we'll want a pathway where we can get the original VOM results
// from finish so we don't end up wasting CPU & memory here.
// Prepare the byte array array that can be accessed from Swift via C.malloc
vomResultsMemory := C.malloc(C.size_t(numResults * int(C.sizeofSwiftByteArray)))
// Make that malloc'd memory available as a slice to Go.
vomResultsPtrsHdr := reflect.SliceHeader{
Data: uintptr(vomResultsMemory),
Len: numResults,
Cap: numResults,
}
vomResults := *(*[]C.SwiftByteArray)(unsafe.Pointer(&vomResultsPtrsHdr))
// Create the C Struct to return that encapsulates our byte array array
var cVomResults C.SwiftByteArrayArray
cVomResults.length = C._GoUint64(numResults)
cVomResults.data = (*C.SwiftByteArray)(vomResultsMemory)
// For each result, VOM encode into a byte array that we stick into the returned struct
for i, resultPtr := range resultPtrs {
// Remove the pointer from the result. Simply *resultPtr doesn't work
// as resultPtr is of type interface{}.
result := interface{}(sutil.DerefOrDie(resultPtr))
var vomResult []byte
var err error
if vomResult, err = vom.Encode(result); err != nil {
return EmptySwiftByteArrayArray(), err
}
cVomResultCopy := C.malloc(C.size_t(len(vomResult)))
C.memcpy(cVomResultCopy, unsafe.Pointer(&vomResult[0]), C.size_t(len(vomResult)))
var cVomResult C.SwiftByteArray
cVomResult.length = C._GoUint64(len(vomResult))
cVomResult.data = cVomResultCopy
vomResults[i] = cVomResult
}
return cVomResults, nil
}
func (i *invoker) Invoke(ctx *context.T, call rpc.StreamServerCall, method string, argptrs []interface{}) (results []interface{}, err error) {
env, freeFunc := jutil.GetEnv()
jContext, err := jcontext.JavaContext(env, ctx, nil)
if err != nil {
freeFunc()
return nil, err
}
jStreamServerCall, err := javaStreamServerCall(env, jContext, call)
if err != nil {
freeFunc()
return nil, err
}
vomArgs := make([][]byte, len(argptrs))
for i, argptr := range argptrs {
arg := interface{}(jutil.DerefOrDie(argptr))
var err error
if vomArgs[i], err = vom.Encode(arg); err != nil {
freeFunc()
return nil, err
}
}
// This method will invoke the freeFunc().
jResult, err := jutil.CallStaticFutureMethod(env, freeFunc, jServerRPCHelperClass, "invoke", []jutil.Sign{invokerSign, contextSign, streamServerCallSign, jutil.StringSign, jutil.ArraySign(jutil.ArraySign(jutil.ByteSign))}, i.jInvoker, jContext, jStreamServerCall, jutil.CamelCase(method), vomArgs)
if err != nil {
return nil, err
}
env, freeFunc = jutil.GetEnv()
defer freeFunc()
defer jutil.DeleteGlobalRef(env, jResult)
vomResults, err := jutil.GoByteArrayArray(env, jResult)
if err != nil {
return nil, err
}
results = make([]interface{}, len(vomResults))
for i, vomResult := range vomResults {
var err error
if results[i], err = jutil.VomDecodeToValue(vomResult); err != nil {
return nil, err
}
}
return results, nil
}
func BenchmarkVomEncoding(b *testing.B) {
for i := 0; i < b.N; i++ {
vom.Encode(vdlCustomer)
}
}