github.com/c-darwin/mobile@v0.0.0-20160313183840-ff625c46f7c9/bind/objc/testpkg/go_testpkg/go_testpkg.go (about)

     1  // Package go_testpkg is an autogenerated binder stub for package testpkg.
     2  //   gobind -lang=go github.com/c-darwin/mobile/bind/objc/testpkg
     3  //
     4  // File is generated by gobind. Do not edit.
     5  package go_testpkg
     6  
     7  import (
     8  	"github.com/c-darwin/mobile/bind/objc/testpkg"
     9  	"github.com/c-darwin/mobile/bind/seq"
    10  )
    11  
    12  func proxy_BytesAppend(out, in *seq.Buffer) {
    13  	param_a := in.ReadByteArray()
    14  	param_b := in.ReadByteArray()
    15  	res := testpkg.BytesAppend(param_a, param_b)
    16  	out.WriteByteArray(res)
    17  }
    18  
    19  func proxy_CallIError(out, in *seq.Buffer) {
    20  	var param_i testpkg.I
    21  	param_i_ref := in.ReadRef()
    22  	if param_i_ref.Num < 0 { // go object
    23  		param_i = param_i_ref.Get().(testpkg.I)
    24  	} else { // foreign object
    25  		param_i = (*proxyI)(param_i_ref)
    26  	}
    27  	param_triggerError := in.ReadBool()
    28  	err := testpkg.CallIError(param_i, param_triggerError)
    29  	if err == nil {
    30  		out.WriteString("")
    31  	} else {
    32  		out.WriteString(err.Error())
    33  	}
    34  }
    35  
    36  func proxy_CallSSum(out, in *seq.Buffer) {
    37  	// Must be a Go object
    38  	param_s_ref := in.ReadRef()
    39  	param_s := param_s_ref.Get().(*testpkg.S)
    40  	res := testpkg.CallSSum(param_s)
    41  	out.WriteFloat64(res)
    42  }
    43  
    44  func proxy_CollectS(out, in *seq.Buffer) {
    45  	param_want := in.ReadInt()
    46  	param_timeoutSec := in.ReadInt()
    47  	res := testpkg.CollectS(param_want, param_timeoutSec)
    48  	out.WriteInt(res)
    49  }
    50  
    51  func proxy_GC(out, in *seq.Buffer) {
    52  	testpkg.GC()
    53  }
    54  
    55  func proxy_Hello(out, in *seq.Buffer) {
    56  	param_s := in.ReadString()
    57  	res := testpkg.Hello(param_s)
    58  	out.WriteString(res)
    59  }
    60  
    61  func proxy_Hi(out, in *seq.Buffer) {
    62  	testpkg.Hi()
    63  }
    64  
    65  const (
    66  	proxyI_Descriptor = "go.testpkg.I"
    67  	proxyI_Error_Code = 0x10a
    68  	proxyI_Times_Code = 0x20a
    69  )
    70  
    71  func proxyI_Error(out, in *seq.Buffer) {
    72  	ref := in.ReadRef()
    73  	v := ref.Get().(testpkg.I)
    74  	param_triggerError := in.ReadBool()
    75  	err := v.Error(param_triggerError)
    76  	if err == nil {
    77  		out.WriteString("")
    78  	} else {
    79  		out.WriteString(err.Error())
    80  	}
    81  }
    82  
    83  func proxyI_Times(out, in *seq.Buffer) {
    84  	ref := in.ReadRef()
    85  	v := ref.Get().(testpkg.I)
    86  	param_v := in.ReadInt32()
    87  	res := v.Times(param_v)
    88  	out.WriteInt64(res)
    89  }
    90  
    91  func init() {
    92  	seq.Register(proxyI_Descriptor, proxyI_Error_Code, proxyI_Error)
    93  	seq.Register(proxyI_Descriptor, proxyI_Times_Code, proxyI_Times)
    94  }
    95  
    96  type proxyI seq.Ref
    97  
    98  func (p *proxyI) Error(triggerError bool) error {
    99  	in := new(seq.Buffer)
   100  	in.WriteBool(triggerError)
   101  	out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_Error_Code, in)
   102  	res_0 := out.ReadError()
   103  	return res_0
   104  }
   105  
   106  func (p *proxyI) Times(v int32) int64 {
   107  	in := new(seq.Buffer)
   108  	in.WriteInt32(v)
   109  	out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_Times_Code, in)
   110  	res_0 := out.ReadInt64()
   111  	return res_0
   112  }
   113  
   114  func proxy_Int(out, in *seq.Buffer) {
   115  	param_x := in.ReadInt32()
   116  	testpkg.Int(param_x)
   117  }
   118  
   119  func proxy_Multiply(out, in *seq.Buffer) {
   120  	param_idx := in.ReadInt32()
   121  	param_val := in.ReadInt32()
   122  	res := testpkg.Multiply(param_idx, param_val)
   123  	out.WriteInt64(res)
   124  }
   125  
   126  func proxy_NewI(out, in *seq.Buffer) {
   127  	res := testpkg.NewI()
   128  	out.WriteGoRef(res)
   129  }
   130  
   131  func proxy_NewNode(out, in *seq.Buffer) {
   132  	param_name := in.ReadString()
   133  	res := testpkg.NewNode(param_name)
   134  	out.WriteGoRef(res)
   135  }
   136  
   137  func proxy_NewS(out, in *seq.Buffer) {
   138  	param_x := in.ReadFloat64()
   139  	param_y := in.ReadFloat64()
   140  	res := testpkg.NewS(param_x, param_y)
   141  	out.WriteGoRef(res)
   142  }
   143  
   144  const (
   145  	proxyNode_Descriptor   = "go.testpkg.Node"
   146  	proxyNode_V_Get_Code   = 0x00f
   147  	proxyNode_V_Set_Code   = 0x01f
   148  	proxyNode_Err_Get_Code = 0x10f
   149  	proxyNode_Err_Set_Code = 0x11f
   150  )
   151  
   152  type proxyNode seq.Ref
   153  
   154  func proxyNode_V_Set(out, in *seq.Buffer) {
   155  	ref := in.ReadRef()
   156  	v := in.ReadString()
   157  	ref.Get().(*testpkg.Node).V = v
   158  }
   159  
   160  func proxyNode_V_Get(out, in *seq.Buffer) {
   161  	ref := in.ReadRef()
   162  	v := ref.Get().(*testpkg.Node).V
   163  	out.WriteString(v)
   164  }
   165  
   166  func proxyNode_Err_Set(out, in *seq.Buffer) {
   167  	ref := in.ReadRef()
   168  	v := in.ReadError()
   169  	ref.Get().(*testpkg.Node).Err = v
   170  }
   171  
   172  func proxyNode_Err_Get(out, in *seq.Buffer) {
   173  	ref := in.ReadRef()
   174  	v := ref.Get().(*testpkg.Node).Err
   175  	if v == nil {
   176  		out.WriteString("")
   177  	} else {
   178  		out.WriteString(v.Error())
   179  	}
   180  }
   181  
   182  func init() {
   183  	seq.Register(proxyNode_Descriptor, proxyNode_V_Set_Code, proxyNode_V_Set)
   184  	seq.Register(proxyNode_Descriptor, proxyNode_V_Get_Code, proxyNode_V_Get)
   185  	seq.Register(proxyNode_Descriptor, proxyNode_Err_Set_Code, proxyNode_Err_Set)
   186  	seq.Register(proxyNode_Descriptor, proxyNode_Err_Get_Code, proxyNode_Err_Get)
   187  }
   188  
   189  func proxy_RegisterI(out, in *seq.Buffer) {
   190  	param_idx := in.ReadInt32()
   191  	var param_i testpkg.I
   192  	param_i_ref := in.ReadRef()
   193  	if param_i_ref.Num < 0 { // go object
   194  		param_i = param_i_ref.Get().(testpkg.I)
   195  	} else { // foreign object
   196  		param_i = (*proxyI)(param_i_ref)
   197  	}
   198  	testpkg.RegisterI(param_idx, param_i)
   199  }
   200  
   201  func proxy_ReturnsError(out, in *seq.Buffer) {
   202  	param_b := in.ReadBool()
   203  	res, err := testpkg.ReturnsError(param_b)
   204  	out.WriteString(res)
   205  	if err == nil {
   206  		out.WriteString("")
   207  	} else {
   208  		out.WriteString(err.Error())
   209  	}
   210  }
   211  
   212  const (
   213  	proxyS_Descriptor         = "go.testpkg.S"
   214  	proxyS_X_Get_Code         = 0x00f
   215  	proxyS_X_Set_Code         = 0x01f
   216  	proxyS_Y_Get_Code         = 0x10f
   217  	proxyS_Y_Set_Code         = 0x11f
   218  	proxyS_Sum_Code           = 0x00c
   219  	proxyS_TryTwoStrings_Code = 0x10c
   220  )
   221  
   222  type proxyS seq.Ref
   223  
   224  func proxyS_X_Set(out, in *seq.Buffer) {
   225  	ref := in.ReadRef()
   226  	v := in.ReadFloat64()
   227  	ref.Get().(*testpkg.S).X = v
   228  }
   229  
   230  func proxyS_X_Get(out, in *seq.Buffer) {
   231  	ref := in.ReadRef()
   232  	v := ref.Get().(*testpkg.S).X
   233  	out.WriteFloat64(v)
   234  }
   235  
   236  func proxyS_Y_Set(out, in *seq.Buffer) {
   237  	ref := in.ReadRef()
   238  	v := in.ReadFloat64()
   239  	ref.Get().(*testpkg.S).Y = v
   240  }
   241  
   242  func proxyS_Y_Get(out, in *seq.Buffer) {
   243  	ref := in.ReadRef()
   244  	v := ref.Get().(*testpkg.S).Y
   245  	out.WriteFloat64(v)
   246  }
   247  
   248  func proxyS_Sum(out, in *seq.Buffer) {
   249  	ref := in.ReadRef()
   250  	v := ref.Get().(*testpkg.S)
   251  	res := v.Sum()
   252  	out.WriteFloat64(res)
   253  }
   254  
   255  func proxyS_TryTwoStrings(out, in *seq.Buffer) {
   256  	ref := in.ReadRef()
   257  	v := ref.Get().(*testpkg.S)
   258  	param_first := in.ReadString()
   259  	param_second := in.ReadString()
   260  	res := v.TryTwoStrings(param_first, param_second)
   261  	out.WriteString(res)
   262  }
   263  
   264  func init() {
   265  	seq.Register(proxyS_Descriptor, proxyS_X_Set_Code, proxyS_X_Set)
   266  	seq.Register(proxyS_Descriptor, proxyS_X_Get_Code, proxyS_X_Get)
   267  	seq.Register(proxyS_Descriptor, proxyS_Y_Set_Code, proxyS_Y_Set)
   268  	seq.Register(proxyS_Descriptor, proxyS_Y_Get_Code, proxyS_Y_Get)
   269  	seq.Register(proxyS_Descriptor, proxyS_Sum_Code, proxyS_Sum)
   270  	seq.Register(proxyS_Descriptor, proxyS_TryTwoStrings_Code, proxyS_TryTwoStrings)
   271  }
   272  
   273  func proxy_Sum(out, in *seq.Buffer) {
   274  	param_x := in.ReadInt64()
   275  	param_y := in.ReadInt64()
   276  	res := testpkg.Sum(param_x, param_y)
   277  	out.WriteInt64(res)
   278  }
   279  
   280  func proxy_UnregisterI(out, in *seq.Buffer) {
   281  	param_idx := in.ReadInt32()
   282  	testpkg.UnregisterI(param_idx)
   283  }
   284  
   285  func init() {
   286  	seq.Register("testpkg", 1, proxy_BytesAppend)
   287  	seq.Register("testpkg", 2, proxy_CallIError)
   288  	seq.Register("testpkg", 3, proxy_CallSSum)
   289  	seq.Register("testpkg", 4, proxy_CollectS)
   290  	seq.Register("testpkg", 5, proxy_GC)
   291  	seq.Register("testpkg", 6, proxy_Hello)
   292  	seq.Register("testpkg", 7, proxy_Hi)
   293  	seq.Register("testpkg", 8, proxy_Int)
   294  	seq.Register("testpkg", 9, proxy_Multiply)
   295  	seq.Register("testpkg", 10, proxy_NewI)
   296  	seq.Register("testpkg", 11, proxy_NewNode)
   297  	seq.Register("testpkg", 12, proxy_NewS)
   298  	seq.Register("testpkg", 13, proxy_RegisterI)
   299  	seq.Register("testpkg", 14, proxy_ReturnsError)
   300  	seq.Register("testpkg", 15, proxy_Sum)
   301  	seq.Register("testpkg", 16, proxy_UnregisterI)
   302  }