// 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 (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
}
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 proxy_StopClientProxy(out, in *seq.Buffer) {
err := flashlight.StopClientProxy()
if err == nil {
out.WriteUTF16("")
} else {
out.WriteUTF16(err.Error())
}
}
func (p *proxyI) StringError(s string) (string, error) {
in := new(seq.Buffer)
in.WriteString(s)
out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_StringError_Code, in)
res_0 := out.ReadString()
res_1 := out.ReadError()
return res_0, res_1
}
func proxy_CallF(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)
}
testpkg.CallF(param_i)
}
func var_setInterfaceVar(out, in *seq.Buffer) {
var v testpkg.I
v_ref := in.ReadRef()
if v_ref.Num < 0 { // go object
v = v_ref.Get().(testpkg.I)
} else { // foreign object
v = (*proxyI)(v_ref)
}
testpkg.InterfaceVar = v
}
func proxy_Keep(out, in *seq.Buffer) {
var param_i testpkg.I
param_i_ref := in.ReadRef()
if param_i_ref.Num < 0 {
param_i = param_i_ref.Get().(testpkg.I)
} else {
param_i = (*proxyI)(param_i_ref)
}
testpkg.Keep(param_i)
}
// 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]
in := new(seq.Buffer)
if reqlen > 0 {
in.Data = (*[maxSliceLen]byte)(unsafe.Pointer(req))[:reqlen]
}
out := new(seq.Buffer)
fn(out, in)
seqToBuf(res, reslen, out)
}
func proxyStructThatStartsWithLetterBeforeZ_Value_Set(out, in *seq.Buffer) {
ref := in.ReadRef()
var v testpkg.Z
v_ref := in.ReadRef()
if v_ref.Num < 0 { // go object
v = v_ref.Get().(testpkg.Z)
} else { // foreign object
v = (*proxyZ)(v_ref)
}
ref.Get().(*testpkg.StructThatStartsWithLetterBeforeZ).Value = v
}
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 proxyI_StringError(out, in *seq.Buffer) {
ref := in.ReadRef()
v := ref.Get().(testpkg.I)
param_s := in.ReadString()
res, err := v.StringError(param_s)
out.WriteString(res)
if err == nil {
out.WriteString("")
} else {
out.WriteString(err.Error())
}
}
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_CallIStringError(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_s := in.ReadString()
res, err := testpkg.CallIStringError(param_i, param_s)
out.WriteString(res)
if err == nil {
out.WriteString("")
} else {
out.WriteString(err.Error())
}
}
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 proxyIVE(out, in *seq.Buffer) {
ref := in.ReadRef()
v := ref.Get().(testpkg.I)
res, err := v.VE()
out.WriteInt(res)
if err == nil {
out.WriteUTF16("")
} else {
out.WriteUTF16(err.Error())
}
}
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_CallVE(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)
}
res, err := testpkg.CallVE(param_i)
out.WriteInt(res)
if err == nil {
out.WriteUTF16("")
} else {
out.WriteUTF16(err.Error())
}
}
func proxy_Err(out, in *seq.Buffer) {
param_s := in.ReadUTF16()
err := testpkg.Err(param_s)
if err == nil {
out.WriteUTF16("")
} else {
out.WriteUTF16(err.Error())
}
}
func proxy_RunClientProxy(out, in *seq.Buffer) {
param_listenAddr := in.ReadUTF16()
err := flashlight.RunClientProxy(param_listenAddr)
if err == nil {
out.WriteUTF16("")
} else {
out.WriteUTF16(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 proxyS_Y_Get(out, in *seq.Buffer) {
ref := in.ReadRef()
v := ref.Get().(*testpkg.S).Y
out.WriteFloat64(v)
}
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_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 proxyS_Sum(out, in *seq.Buffer) {
ref := in.ReadRef()
v := ref.Get().(*testpkg.S)
res := v.Sum()
out.WriteFloat64(res)
}