github.com/graybobo/golang.org-package-offline-cache@v0.0.0-20200626051047-6608995c132f/x/mobile/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 golang.org/x/mobile/bind/objc/testpkg
     3  //
     4  // File is generated by gobind. Do not edit.
     5  package go_testpkg
     6  
     7  import (
     8  	"golang.org/x/mobile/bind/objc/testpkg"
     9  	"golang.org/x/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_CallIStringError(out, in *seq.Buffer) {
    37  	var param_i testpkg.I
    38  	param_i_ref := in.ReadRef()
    39  	if param_i_ref.Num < 0 { // go object
    40  		param_i = param_i_ref.Get().(testpkg.I)
    41  	} else { // foreign object
    42  		param_i = (*proxyI)(param_i_ref)
    43  	}
    44  	param_s := in.ReadString()
    45  	res, err := testpkg.CallIStringError(param_i, param_s)
    46  	out.WriteString(res)
    47  	if err == nil {
    48  		out.WriteString("")
    49  	} else {
    50  		out.WriteString(err.Error())
    51  	}
    52  }
    53  
    54  func proxy_CallSSum(out, in *seq.Buffer) {
    55  	// Must be a Go object
    56  	param_s_ref := in.ReadRef()
    57  	param_s := param_s_ref.Get().(*testpkg.S)
    58  	res := testpkg.CallSSum(param_s)
    59  	out.WriteFloat64(res)
    60  }
    61  
    62  func proxy_CollectS(out, in *seq.Buffer) {
    63  	param_want := in.ReadInt()
    64  	param_timeoutSec := in.ReadInt()
    65  	res := testpkg.CollectS(param_want, param_timeoutSec)
    66  	out.WriteInt(res)
    67  }
    68  
    69  func proxy_Echo(out, in *seq.Buffer) {
    70  	param_s := in.ReadString()
    71  	res := testpkg.Echo(param_s)
    72  	out.WriteString(res)
    73  }
    74  
    75  func proxy_GC(out, in *seq.Buffer) {
    76  	testpkg.GC()
    77  }
    78  
    79  func proxy_Hello(out, in *seq.Buffer) {
    80  	param_s := in.ReadString()
    81  	res := testpkg.Hello(param_s)
    82  	out.WriteString(res)
    83  }
    84  
    85  func proxy_Hi(out, in *seq.Buffer) {
    86  	testpkg.Hi()
    87  }
    88  
    89  const (
    90  	proxyI_Descriptor       = "go.testpkg.I"
    91  	proxyI_Error_Code       = 0x10a
    92  	proxyI_StringError_Code = 0x20a
    93  	proxyI_Times_Code       = 0x30a
    94  )
    95  
    96  func proxyI_Error(out, in *seq.Buffer) {
    97  	ref := in.ReadRef()
    98  	v := ref.Get().(testpkg.I)
    99  	param_triggerError := in.ReadBool()
   100  	err := v.Error(param_triggerError)
   101  	if err == nil {
   102  		out.WriteString("")
   103  	} else {
   104  		out.WriteString(err.Error())
   105  	}
   106  }
   107  
   108  func proxyI_StringError(out, in *seq.Buffer) {
   109  	ref := in.ReadRef()
   110  	v := ref.Get().(testpkg.I)
   111  	param_s := in.ReadString()
   112  	res, err := v.StringError(param_s)
   113  	out.WriteString(res)
   114  	if err == nil {
   115  		out.WriteString("")
   116  	} else {
   117  		out.WriteString(err.Error())
   118  	}
   119  }
   120  
   121  func proxyI_Times(out, in *seq.Buffer) {
   122  	ref := in.ReadRef()
   123  	v := ref.Get().(testpkg.I)
   124  	param_v := in.ReadInt32()
   125  	res := v.Times(param_v)
   126  	out.WriteInt64(res)
   127  }
   128  
   129  func init() {
   130  	seq.Register(proxyI_Descriptor, proxyI_Error_Code, proxyI_Error)
   131  	seq.Register(proxyI_Descriptor, proxyI_StringError_Code, proxyI_StringError)
   132  	seq.Register(proxyI_Descriptor, proxyI_Times_Code, proxyI_Times)
   133  }
   134  
   135  type proxyI seq.Ref
   136  
   137  func (p *proxyI) Error(triggerError bool) error {
   138  	in := new(seq.Buffer)
   139  	in.WriteBool(triggerError)
   140  	out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_Error_Code, in)
   141  	res_0 := out.ReadError()
   142  	return res_0
   143  }
   144  
   145  func (p *proxyI) StringError(s string) (string, error) {
   146  	in := new(seq.Buffer)
   147  	in.WriteString(s)
   148  	out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_StringError_Code, in)
   149  	res_0 := out.ReadString()
   150  	res_1 := out.ReadError()
   151  	return res_0, res_1
   152  }
   153  
   154  func (p *proxyI) Times(v int32) int64 {
   155  	in := new(seq.Buffer)
   156  	in.WriteInt32(v)
   157  	out := seq.Transact((*seq.Ref)(p), "go.testpkg.I", proxyI_Times_Code, in)
   158  	res_0 := out.ReadInt64()
   159  	return res_0
   160  }
   161  
   162  func proxy_Int(out, in *seq.Buffer) {
   163  	param_x := in.ReadInt32()
   164  	testpkg.Int(param_x)
   165  }
   166  
   167  func var_setIntVar(out, in *seq.Buffer) {
   168  	v := in.ReadInt()
   169  	testpkg.IntVar = v
   170  }
   171  func var_getIntVar(out, in *seq.Buffer) {
   172  	out.WriteInt(testpkg.IntVar)
   173  }
   174  func var_setInterfaceVar(out, in *seq.Buffer) {
   175  	var v testpkg.I
   176  	v_ref := in.ReadRef()
   177  	if v_ref.Num < 0 { // go object
   178  		v = v_ref.Get().(testpkg.I)
   179  	} else { // foreign object
   180  		v = (*proxyI)(v_ref)
   181  	}
   182  	testpkg.InterfaceVar = v
   183  }
   184  func var_getInterfaceVar(out, in *seq.Buffer) {
   185  	out.WriteGoRef(testpkg.InterfaceVar)
   186  }
   187  func proxy_Multiply(out, in *seq.Buffer) {
   188  	param_idx := in.ReadInt32()
   189  	param_val := in.ReadInt32()
   190  	res := testpkg.Multiply(param_idx, param_val)
   191  	out.WriteInt64(res)
   192  }
   193  
   194  func proxy_NewI(out, in *seq.Buffer) {
   195  	res := testpkg.NewI()
   196  	out.WriteGoRef(res)
   197  }
   198  
   199  func proxy_NewNode(out, in *seq.Buffer) {
   200  	param_name := in.ReadString()
   201  	res := testpkg.NewNode(param_name)
   202  	out.WriteGoRef(res)
   203  }
   204  
   205  func proxy_NewS(out, in *seq.Buffer) {
   206  	param_x := in.ReadFloat64()
   207  	param_y := in.ReadFloat64()
   208  	res := testpkg.NewS(param_x, param_y)
   209  	out.WriteGoRef(res)
   210  }
   211  
   212  const (
   213  	proxyNode_Descriptor   = "go.testpkg.Node"
   214  	proxyNode_V_Get_Code   = 0x00f
   215  	proxyNode_V_Set_Code   = 0x01f
   216  	proxyNode_Err_Get_Code = 0x10f
   217  	proxyNode_Err_Set_Code = 0x11f
   218  )
   219  
   220  type proxyNode seq.Ref
   221  
   222  func proxyNode_V_Set(out, in *seq.Buffer) {
   223  	ref := in.ReadRef()
   224  	v := in.ReadString()
   225  	ref.Get().(*testpkg.Node).V = v
   226  }
   227  
   228  func proxyNode_V_Get(out, in *seq.Buffer) {
   229  	ref := in.ReadRef()
   230  	v := ref.Get().(*testpkg.Node).V
   231  	out.WriteString(v)
   232  }
   233  
   234  func proxyNode_Err_Set(out, in *seq.Buffer) {
   235  	ref := in.ReadRef()
   236  	v := in.ReadError()
   237  	ref.Get().(*testpkg.Node).Err = v
   238  }
   239  
   240  func proxyNode_Err_Get(out, in *seq.Buffer) {
   241  	ref := in.ReadRef()
   242  	v := ref.Get().(*testpkg.Node).Err
   243  	if v == nil {
   244  		out.WriteString("")
   245  	} else {
   246  		out.WriteString(v.Error())
   247  	}
   248  }
   249  
   250  func init() {
   251  	seq.Register(proxyNode_Descriptor, proxyNode_V_Set_Code, proxyNode_V_Set)
   252  	seq.Register(proxyNode_Descriptor, proxyNode_V_Get_Code, proxyNode_V_Get)
   253  	seq.Register(proxyNode_Descriptor, proxyNode_Err_Set_Code, proxyNode_Err_Set)
   254  	seq.Register(proxyNode_Descriptor, proxyNode_Err_Get_Code, proxyNode_Err_Get)
   255  }
   256  
   257  func proxy_RegisterI(out, in *seq.Buffer) {
   258  	param_idx := in.ReadInt32()
   259  	var param_i testpkg.I
   260  	param_i_ref := in.ReadRef()
   261  	if param_i_ref.Num < 0 { // go object
   262  		param_i = param_i_ref.Get().(testpkg.I)
   263  	} else { // foreign object
   264  		param_i = (*proxyI)(param_i_ref)
   265  	}
   266  	testpkg.RegisterI(param_idx, param_i)
   267  }
   268  
   269  func proxy_ReturnsError(out, in *seq.Buffer) {
   270  	param_b := in.ReadBool()
   271  	res, err := testpkg.ReturnsError(param_b)
   272  	out.WriteString(res)
   273  	if err == nil {
   274  		out.WriteString("")
   275  	} else {
   276  		out.WriteString(err.Error())
   277  	}
   278  }
   279  
   280  const (
   281  	proxyS_Descriptor         = "go.testpkg.S"
   282  	proxyS_X_Get_Code         = 0x00f
   283  	proxyS_X_Set_Code         = 0x01f
   284  	proxyS_Y_Get_Code         = 0x10f
   285  	proxyS_Y_Set_Code         = 0x11f
   286  	proxyS_Sum_Code           = 0x00c
   287  	proxyS_TryTwoStrings_Code = 0x10c
   288  )
   289  
   290  type proxyS seq.Ref
   291  
   292  func proxyS_X_Set(out, in *seq.Buffer) {
   293  	ref := in.ReadRef()
   294  	v := in.ReadFloat64()
   295  	ref.Get().(*testpkg.S).X = v
   296  }
   297  
   298  func proxyS_X_Get(out, in *seq.Buffer) {
   299  	ref := in.ReadRef()
   300  	v := ref.Get().(*testpkg.S).X
   301  	out.WriteFloat64(v)
   302  }
   303  
   304  func proxyS_Y_Set(out, in *seq.Buffer) {
   305  	ref := in.ReadRef()
   306  	v := in.ReadFloat64()
   307  	ref.Get().(*testpkg.S).Y = v
   308  }
   309  
   310  func proxyS_Y_Get(out, in *seq.Buffer) {
   311  	ref := in.ReadRef()
   312  	v := ref.Get().(*testpkg.S).Y
   313  	out.WriteFloat64(v)
   314  }
   315  
   316  func proxyS_Sum(out, in *seq.Buffer) {
   317  	ref := in.ReadRef()
   318  	v := ref.Get().(*testpkg.S)
   319  	res := v.Sum()
   320  	out.WriteFloat64(res)
   321  }
   322  
   323  func proxyS_TryTwoStrings(out, in *seq.Buffer) {
   324  	ref := in.ReadRef()
   325  	v := ref.Get().(*testpkg.S)
   326  	param_first := in.ReadString()
   327  	param_second := in.ReadString()
   328  	res := v.TryTwoStrings(param_first, param_second)
   329  	out.WriteString(res)
   330  }
   331  
   332  func init() {
   333  	seq.Register(proxyS_Descriptor, proxyS_X_Set_Code, proxyS_X_Set)
   334  	seq.Register(proxyS_Descriptor, proxyS_X_Get_Code, proxyS_X_Get)
   335  	seq.Register(proxyS_Descriptor, proxyS_Y_Set_Code, proxyS_Y_Set)
   336  	seq.Register(proxyS_Descriptor, proxyS_Y_Get_Code, proxyS_Y_Get)
   337  	seq.Register(proxyS_Descriptor, proxyS_Sum_Code, proxyS_Sum)
   338  	seq.Register(proxyS_Descriptor, proxyS_TryTwoStrings_Code, proxyS_TryTwoStrings)
   339  }
   340  
   341  func var_setStringVar(out, in *seq.Buffer) {
   342  	v := in.ReadString()
   343  	testpkg.StringVar = v
   344  }
   345  func var_getStringVar(out, in *seq.Buffer) {
   346  	out.WriteString(testpkg.StringVar)
   347  }
   348  
   349  const (
   350  	proxyStructThatStartsWithLetterBeforeZ_Descriptor     = "go.testpkg.StructThatStartsWithLetterBeforeZ"
   351  	proxyStructThatStartsWithLetterBeforeZ_Value_Get_Code = 0x00f
   352  	proxyStructThatStartsWithLetterBeforeZ_Value_Set_Code = 0x01f
   353  )
   354  
   355  type proxyStructThatStartsWithLetterBeforeZ seq.Ref
   356  
   357  func proxyStructThatStartsWithLetterBeforeZ_Value_Set(out, in *seq.Buffer) {
   358  	ref := in.ReadRef()
   359  	var v testpkg.Z
   360  	v_ref := in.ReadRef()
   361  	if v_ref.Num < 0 { // go object
   362  		v = v_ref.Get().(testpkg.Z)
   363  	} else { // foreign object
   364  		v = (*proxyZ)(v_ref)
   365  	}
   366  	ref.Get().(*testpkg.StructThatStartsWithLetterBeforeZ).Value = v
   367  }
   368  
   369  func proxyStructThatStartsWithLetterBeforeZ_Value_Get(out, in *seq.Buffer) {
   370  	ref := in.ReadRef()
   371  	v := ref.Get().(*testpkg.StructThatStartsWithLetterBeforeZ).Value
   372  	out.WriteGoRef(v)
   373  }
   374  
   375  func init() {
   376  	seq.Register(proxyStructThatStartsWithLetterBeforeZ_Descriptor, proxyStructThatStartsWithLetterBeforeZ_Value_Set_Code, proxyStructThatStartsWithLetterBeforeZ_Value_Set)
   377  	seq.Register(proxyStructThatStartsWithLetterBeforeZ_Descriptor, proxyStructThatStartsWithLetterBeforeZ_Value_Get_Code, proxyStructThatStartsWithLetterBeforeZ_Value_Get)
   378  }
   379  
   380  func var_setStructVar(out, in *seq.Buffer) {
   381  	// Must be a Go object
   382  	v_ref := in.ReadRef()
   383  	v := v_ref.Get().(*testpkg.Node)
   384  	testpkg.StructVar = v
   385  }
   386  func var_getStructVar(out, in *seq.Buffer) {
   387  	out.WriteGoRef(testpkg.StructVar)
   388  }
   389  func proxy_Sum(out, in *seq.Buffer) {
   390  	param_x := in.ReadInt64()
   391  	param_y := in.ReadInt64()
   392  	res := testpkg.Sum(param_x, param_y)
   393  	out.WriteInt64(res)
   394  }
   395  
   396  func proxy_UnregisterI(out, in *seq.Buffer) {
   397  	param_idx := in.ReadInt32()
   398  	testpkg.UnregisterI(param_idx)
   399  }
   400  
   401  const (
   402  	proxyZ_Descriptor = "go.testpkg.Z"
   403  )
   404  
   405  type proxyZ seq.Ref
   406  
   407  func init() {
   408  	seq.Register("testpkg", 1, proxy_BytesAppend)
   409  	seq.Register("testpkg", 2, proxy_CallIError)
   410  	seq.Register("testpkg", 3, proxy_CallIStringError)
   411  	seq.Register("testpkg", 4, proxy_CallSSum)
   412  	seq.Register("testpkg", 5, proxy_CollectS)
   413  	seq.Register("testpkg", 6, proxy_Echo)
   414  	seq.Register("testpkg", 7, proxy_GC)
   415  	seq.Register("testpkg", 8, proxy_Hello)
   416  	seq.Register("testpkg", 9, proxy_Hi)
   417  	seq.Register("testpkg", 10, proxy_Int)
   418  	seq.Register("testpkg", 11, proxy_Multiply)
   419  	seq.Register("testpkg", 12, proxy_NewI)
   420  	seq.Register("testpkg", 13, proxy_NewNode)
   421  	seq.Register("testpkg", 14, proxy_NewS)
   422  	seq.Register("testpkg", 15, proxy_RegisterI)
   423  	seq.Register("testpkg", 16, proxy_ReturnsError)
   424  	seq.Register("testpkg", 17, proxy_Sum)
   425  	seq.Register("testpkg", 18, proxy_UnregisterI)
   426  }
   427  func init() {
   428  	seq.Register("testpkg.IntVar", 1, var_setIntVar)
   429  	seq.Register("testpkg.IntVar", 2, var_getIntVar)
   430  	seq.Register("testpkg.InterfaceVar", 1, var_setInterfaceVar)
   431  	seq.Register("testpkg.InterfaceVar", 2, var_getInterfaceVar)
   432  	seq.Register("testpkg.StringVar", 1, var_setStringVar)
   433  	seq.Register("testpkg.StringVar", 2, var_getStringVar)
   434  	seq.Register("testpkg.StructVar", 1, var_setStructVar)
   435  	seq.Register("testpkg.StructVar", 2, var_getStructVar)
   436  }