func (p *proxyI) Times(v int32) int64 { in := new(seq.Buffer) in.WriteInt32(v) out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_Times_Code, in) res_0 := out.ReadInt64() return res_0 }
func proxy_CallSSum(out, in *seq.Buffer) { // Must be a Go object param_s_ref := in.ReadRef() param_s := param_s_ref.Get().(*testpkg.S) res := testpkg.CallSSum(param_s) out.WriteFloat64(res) }
func (p *proxyI) Error(triggerError bool) error { in := new(seq.Buffer) in.WriteBool(triggerError) out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_Error_Code, in) res_0 := out.ReadError() return res_0 }
// transact calls a method on an Objective-C object instance. // It blocks until the call is complete. // // Code (>0) is the method id assigned by gobind. // Code -1 is used to instruct Objective-C to decrement the ref count of // the Objective-Co object. func transact(ref *seq.Ref, descriptor string, code int, in *seq.Buffer) *seq.Buffer { var ( res *C.uint8_t = nil resLen C.size_t = 0 req *C.uint8_t = nil reqLen C.size_t = 0 ) if len(in.Data) > 0 { req = (*C.uint8_t)(unsafe.Pointer(&in.Data[0])) reqLen = C.size_t(len(in.Data)) } if debug { fmt.Printf("transact: ref.Num = %d code = %d\n", ref.Num, code) } desc := cstrings.get(descriptor) C.go_seq_recv(C.int32_t(ref.Num), desc, C.int(code), req, reqLen, &res, &resLen) if resLen > 0 { goSlice := (*[maxSliceLen]byte)(unsafe.Pointer(res))[:resLen] out := new(seq.Buffer) out.Data = make([]byte, int(resLen)) copy(out.Data, goSlice) C.free(unsafe.Pointer(res)) // TODO: own or copy []bytes whose addresses were passed in. return out } return nil }
func proxy_RegisterI(out, in *seq.Buffer) { param_idx := in.ReadInt32() var param_i testpkg.I param_i_ref := in.ReadRef() if param_i_ref.Num < 0 { // go object param_i = param_i_ref.Get().(testpkg.I) } else { // foreign object param_i = (*proxyI)(param_i_ref) } testpkg.RegisterI(param_idx, param_i) }
func proxyS_TryTwoStrings(out, in *seq.Buffer) { ref := in.ReadRef() v := ref.Get().(*testpkg.S) param_first := in.ReadString() param_second := in.ReadString() res := v.TryTwoStrings(param_first, param_second) out.WriteString(res) }
func proxy_ReturnsError(out, in *seq.Buffer) { param_b := in.ReadBool() res, err := testpkg.ReturnsError(param_b) out.WriteString(res) if err == nil { out.WriteString("") } else { out.WriteString(err.Error()) } }
// Send is called by Java to send a request to run a Go function. //export Send func Send(descriptor string, code int, req *C.uint8_t, reqlen C.size_t, res **C.uint8_t, reslen *C.size_t) { fn := seq.Registry[descriptor][code] if fn == nil { panic(fmt.Sprintf("invalid descriptor(%s) and code(0x%x)", descriptor, code)) } in := new(seq.Buffer) if reqlen > 0 { in.Data = (*[maxSliceLen]byte)(unsafe.Pointer(req))[:reqlen] } out := new(seq.Buffer) fn(out, in) // BUG(hyangah): the function returning a go byte slice (so fn writes a pointer into 'out') is unsafe. // After fn is complete here, Go runtime is free to collect or move the pointed byte slice // contents. (Explicitly calling runtime.GC here will surface the problem?) // Without pinning support from Go side, it will be hard to fix it without extra copying. seqToBuf(res, reslen, out) }
func proxyI_Error(out, in *seq.Buffer) { ref := in.ReadRef() v := ref.Get().(testpkg.I) param_triggerError := in.ReadBool() err := v.Error(param_triggerError) if err == nil { out.WriteString("") } else { out.WriteString(err.Error()) } }
func proxyI_Times(out, in *seq.Buffer) { ref := in.ReadRef() v := ref.Get().(testpkg.I) param_v := in.ReadInt32() res := v.Times(param_v) out.WriteInt64(res) }
func proxy_CallIError(out, in *seq.Buffer) { var param_i testpkg.I param_i_ref := in.ReadRef() if param_i_ref.Num < 0 { // go object param_i = param_i_ref.Get().(testpkg.I) } else { // foreign object param_i = (*proxyI)(param_i_ref) } param_triggerError := in.ReadBool() err := testpkg.CallIError(param_i, param_triggerError) if err == nil { out.WriteString("") } else { out.WriteString(err.Error()) } }
func proxyNode_Err_Get(out, in *seq.Buffer) { ref := in.ReadRef() v := ref.Get().(*testpkg.Node).Err if v == nil { out.WriteString("") } else { out.WriteString(v.Error()) } }
func proxy_Hello(out, in *seq.Buffer) { param_s := in.ReadString() res := testpkg.Hello(param_s) out.WriteString(res) }
func proxy_CollectS(out, in *seq.Buffer) { param_want := in.ReadInt() param_timeoutSec := in.ReadInt() res := testpkg.CollectS(param_want, param_timeoutSec) out.WriteInt(res) }
func proxy_BytesAppend(out, in *seq.Buffer) { param_a := in.ReadByteArray() param_b := in.ReadByteArray() res := testpkg.BytesAppend(param_a, param_b) out.WriteByteArray(res) }
func proxy_UnregisterI(out, in *seq.Buffer) { param_idx := in.ReadInt32() testpkg.UnregisterI(param_idx) }
func proxy_Sum(out, in *seq.Buffer) { param_x := in.ReadInt64() param_y := in.ReadInt64() res := testpkg.Sum(param_x, param_y) out.WriteInt64(res) }
func proxy_NewNode(out, in *seq.Buffer) { param_name := in.ReadString() res := testpkg.NewNode(param_name) out.WriteGoRef(res) }
func proxyNode_V_Get(out, in *seq.Buffer) { ref := in.ReadRef() v := ref.Get().(*testpkg.Node).V out.WriteString(v) }
func proxyS_Y_Get(out, in *seq.Buffer) { ref := in.ReadRef() v := ref.Get().(*testpkg.S).Y out.WriteFloat64(v) }
func proxy_Multiply(out, in *seq.Buffer) { param_idx := in.ReadInt32() param_val := in.ReadInt32() res := testpkg.Multiply(param_idx, param_val) out.WriteInt64(res) }
func proxy_NewS(out, in *seq.Buffer) { param_x := in.ReadFloat64() param_y := in.ReadFloat64() res := testpkg.NewS(param_x, param_y) out.WriteGoRef(res) }
func decodeString(in *seq.Buffer) string { return in.ReadUTF16() }
func proxyNode_Err_Set(out, in *seq.Buffer) { ref := in.ReadRef() v := in.ReadError() ref.Get().(*testpkg.Node).Err = v }
func proxy_NewI(out, in *seq.Buffer) { res := testpkg.NewI() out.WriteGoRef(res) }
func proxyS_Sum(out, in *seq.Buffer) { ref := in.ReadRef() v := ref.Get().(*testpkg.S) res := v.Sum() out.WriteFloat64(res) }
func proxyS_Y_Set(out, in *seq.Buffer) { ref := in.ReadRef() v := in.ReadFloat64() ref.Get().(*testpkg.S).Y = v }
func proxyNode_V_Set(out, in *seq.Buffer) { ref := in.ReadRef() v := in.ReadString() ref.Get().(*testpkg.Node).V = v }
func encodeString(out *seq.Buffer, v string) { out.WriteUTF16(v) }
func proxy_Int(out, in *seq.Buffer) { param_x := in.ReadInt32() testpkg.Int(param_x) }