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) } }