go/src/golang.org/x/mobile/bind/java/testpkg/go_testpkg/go_testpkg.go

// Package go_testpkg is an autogenerated binder stub for package testpkg.
//   gobind -lang=go golang.org/x/mobile/bind/java/testpkg
//
// File is generated by gobind. Do not edit.
package go_testpkg

import (
	"golang.org/x/mobile/bind/java/testpkg"
	"golang.org/x/mobile/bind/seq"
)

func proxy_Add(out, in *seq.Buffer) {
	param_x := in.ReadInt()
	param_y := in.ReadInt()
	res := testpkg.Add(param_x, param_y)
	out.WriteInt(res)
}

func proxy_AppendToString(out, in *seq.Buffer) {
	param_str := in.ReadUTF16()
	param_someBytes := in.ReadByteArray()
	res := testpkg.AppendToString(param_str, param_someBytes)
	out.WriteByteArray(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_CallE(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)
	}
	err := testpkg.CallE(param_i)
	if err == nil {
		out.WriteUTF16("")
	} else {
		out.WriteUTF16(err.Error())
	}
}

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 proxy_CallI(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 := testpkg.CallI(param_i)
	out.WriteGoRef(res)
}

func proxy_CallS(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 := testpkg.CallS(param_i)
	out.WriteGoRef(res)
}

func proxy_CallV(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 := testpkg.CallV(param_i)
	out.WriteInt(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_GC(out, in *seq.Buffer) {
	testpkg.GC()
}

const (
	proxyIDescriptor = "go.testpkg.I"
	proxyIECode      = 0x10a
	proxyIFCode      = 0x20a
	proxyIICode      = 0x30a
	proxyISCode      = 0x40a
	proxyIStringCode = 0x50a
	proxyIVCode      = 0x60a
	proxyIVECode     = 0x70a
)

func proxyIE(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(testpkg.I)
	err := v.E()
	if err == nil {
		out.WriteUTF16("")
	} else {
		out.WriteUTF16(err.Error())
	}
}

func proxyIF(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(testpkg.I)
	v.F()
}

func proxyII(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(testpkg.I)
	res := v.I()
	out.WriteGoRef(res)
}

func proxyIS(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(testpkg.I)
	res := v.S()
	out.WriteGoRef(res)
}

func proxyIString(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(testpkg.I)
	res := v.String()
	out.WriteUTF16(res)
}

func proxyIV(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(testpkg.I)
	res := v.V()
	out.WriteInt(res)
}

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 init() {
	seq.Register(proxyIDescriptor, proxyIECode, proxyIE)
	seq.Register(proxyIDescriptor, proxyIFCode, proxyIF)
	seq.Register(proxyIDescriptor, proxyIICode, proxyII)
	seq.Register(proxyIDescriptor, proxyISCode, proxyIS)
	seq.Register(proxyIDescriptor, proxyIStringCode, proxyIString)
	seq.Register(proxyIDescriptor, proxyIVCode, proxyIV)
	seq.Register(proxyIDescriptor, proxyIVECode, proxyIVE)
}

type proxyI seq.Ref

func (p *proxyI) E() error {
	in := new(seq.Buffer)
	out := seq.Transact((*seq.Ref)(p), proxyIECode, in)
	res_0 := out.ReadError()
	return res_0
}

func (p *proxyI) F() {
	in := new(seq.Buffer)
	seq.Transact((*seq.Ref)(p), proxyIFCode, in)
}

func (p *proxyI) I() testpkg.I {
	in := new(seq.Buffer)
	out := seq.Transact((*seq.Ref)(p), proxyIICode, in)
	var res_0 testpkg.I
	res_0_ref := out.ReadRef()
	if res_0_ref.Num < 0 { // go object
		res_0 = res_0_ref.Get().(testpkg.I)
	} else { // foreign object
		res_0 = (*proxyI)(res_0_ref)
	}
	return res_0
}

func (p *proxyI) S() *testpkg.S {
	in := new(seq.Buffer)
	out := seq.Transact((*seq.Ref)(p), proxyISCode, in)
	// Must be a Go object
	res_0_ref := out.ReadRef()
	res_0 := res_0_ref.Get().(*testpkg.S)
	return res_0
}

func (p *proxyI) String() string {
	in := new(seq.Buffer)
	out := seq.Transact((*seq.Ref)(p), proxyIStringCode, in)
	res_0 := out.ReadUTF16()
	return res_0
}

func (p *proxyI) V() int {
	in := new(seq.Buffer)
	out := seq.Transact((*seq.Ref)(p), proxyIVCode, in)
	res_0 := out.ReadInt()
	return res_0
}

func (p *proxyI) VE() (int, error) {
	in := new(seq.Buffer)
	out := seq.Transact((*seq.Ref)(p), proxyIVECode, in)
	res_0 := out.ReadInt()
	res_1 := out.ReadError()
	return res_0, res_1
}

func proxy_Keep(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.Keep(param_i)
}

func proxy_New(out, in *seq.Buffer) {
	res := testpkg.New()
	out.WriteGoRef(res)
}

func proxy_NumSCollected(out, in *seq.Buffer) {
	res := testpkg.NumSCollected()
	out.WriteInt(res)
}

const (
	proxySDescriptor = "go.testpkg.S"
	proxySFCode      = 0x00c
	proxySStringCode = 0x10c
)

type proxyS seq.Ref

func proxySF(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(*testpkg.S)
	v.F()
}

func proxySString(out, in *seq.Buffer) {
	ref := in.ReadRef()
	v := ref.Get().(*testpkg.S)
	res := v.String()
	out.WriteUTF16(res)
}

func init() {
	seq.Register(proxySDescriptor, proxySFCode, proxySF)
	seq.Register(proxySDescriptor, proxySStringCode, proxySString)
}

func proxy_StrDup(out, in *seq.Buffer) {
	param_s := in.ReadUTF16()
	res := testpkg.StrDup(param_s)
	out.WriteUTF16(res)
}

func init() {
	seq.Register("testpkg", 1, proxy_Add)
	seq.Register("testpkg", 2, proxy_AppendToString)
	seq.Register("testpkg", 3, proxy_BytesAppend)
	seq.Register("testpkg", 4, proxy_CallE)
	seq.Register("testpkg", 5, proxy_CallF)
	seq.Register("testpkg", 6, proxy_CallI)
	seq.Register("testpkg", 7, proxy_CallS)
	seq.Register("testpkg", 8, proxy_CallV)
	seq.Register("testpkg", 9, proxy_CallVE)
	seq.Register("testpkg", 10, proxy_Err)
	seq.Register("testpkg", 11, proxy_GC)
	seq.Register("testpkg", 12, proxy_Keep)
	seq.Register("testpkg", 13, proxy_New)
	seq.Register("testpkg", 14, proxy_NumSCollected)
	seq.Register("testpkg", 15, proxy_StrDup)
}