| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // WARNING: This file is machine generated by fidlgen. |
| |
| // TODO(pascallouis): Instead of copying this file in here, it would be much |
| // better to automatically generate it from the test.fidl file. Additionally, |
| // the build constraint below is added manually. |
| // +build fuchsia |
| |
| package bindingstest |
| |
| import ( |
| _zx "syscall/zx" |
| _bindings "syscall/zx/fidl" |
| ) |
| |
| const ( |
| KMaxBuf uint64 = 8192 |
| ) |
| |
| type TestSimple struct { |
| _ struct{} `fidl2:"s,8,8"` |
| X int64 |
| } |
| |
| var _mTestSimple = _bindings.CreateLazyMarshaler(TestSimple{}) |
| |
| func (msg *TestSimple) Marshaler() _bindings.Marshaler { |
| return _mTestSimple |
| } |
| |
| // Implements Payload. |
| func (_ *TestSimple) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestSimple) InlineSize() int { |
| return 8 |
| } |
| |
| type TestSimpleBool struct { |
| _ struct{} `fidl2:"s,1,1"` |
| X bool |
| } |
| |
| var _mTestSimpleBool = _bindings.CreateLazyMarshaler(TestSimpleBool{}) |
| |
| func (msg *TestSimpleBool) Marshaler() _bindings.Marshaler { |
| return _mTestSimpleBool |
| } |
| |
| // Implements Payload. |
| func (_ *TestSimpleBool) InlineAlignment() int { |
| return 1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestSimpleBool) InlineSize() int { |
| return 1 |
| } |
| |
| type TestAlignment1 struct { |
| _ struct{} `fidl2:"s,8,4"` |
| X int8 |
| Y int8 |
| Z uint32 |
| } |
| |
| var _mTestAlignment1 = _bindings.CreateLazyMarshaler(TestAlignment1{}) |
| |
| func (msg *TestAlignment1) Marshaler() _bindings.Marshaler { |
| return _mTestAlignment1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestAlignment1) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *TestAlignment1) InlineSize() int { |
| return 8 |
| } |
| |
| type TestAlignment2 struct { |
| _ struct{} `fidl2:"s,20,4"` |
| A uint32 |
| B uint32 |
| C int8 |
| D int8 |
| E int8 |
| F uint8 |
| G uint32 |
| H uint16 |
| I uint16 |
| } |
| |
| var _mTestAlignment2 = _bindings.CreateLazyMarshaler(TestAlignment2{}) |
| |
| func (msg *TestAlignment2) Marshaler() _bindings.Marshaler { |
| return _mTestAlignment2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestAlignment2) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *TestAlignment2) InlineSize() int { |
| return 20 |
| } |
| |
| type TestFloat1 struct { |
| _ struct{} `fidl2:"s,4,4"` |
| A float32 |
| } |
| |
| var _mTestFloat1 = _bindings.CreateLazyMarshaler(TestFloat1{}) |
| |
| func (msg *TestFloat1) Marshaler() _bindings.Marshaler { |
| return _mTestFloat1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFloat1) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFloat1) InlineSize() int { |
| return 4 |
| } |
| |
| type TestFloat2 struct { |
| _ struct{} `fidl2:"s,8,8"` |
| A float64 |
| } |
| |
| var _mTestFloat2 = _bindings.CreateLazyMarshaler(TestFloat2{}) |
| |
| func (msg *TestFloat2) Marshaler() _bindings.Marshaler { |
| return _mTestFloat2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFloat2) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFloat2) InlineSize() int { |
| return 8 |
| } |
| |
| type TestFloat3 struct { |
| _ struct{} `fidl2:"s,32,8"` |
| A float32 |
| B float64 |
| C uint64 |
| D float32 |
| } |
| |
| var _mTestFloat3 = _bindings.CreateLazyMarshaler(TestFloat3{}) |
| |
| func (msg *TestFloat3) Marshaler() _bindings.Marshaler { |
| return _mTestFloat3 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFloat3) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFloat3) InlineSize() int { |
| return 32 |
| } |
| |
| type TestArray1 struct { |
| _ struct{} `fidl2:"s,5,1"` |
| A [5]int8 |
| } |
| |
| var _mTestArray1 = _bindings.CreateLazyMarshaler(TestArray1{}) |
| |
| func (msg *TestArray1) Marshaler() _bindings.Marshaler { |
| return _mTestArray1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray1) InlineAlignment() int { |
| return 1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray1) InlineSize() int { |
| return 5 |
| } |
| |
| type TestArray2 struct { |
| _ struct{} `fidl2:"s,16,8"` |
| A float64 |
| B [1]float32 |
| } |
| |
| var _mTestArray2 = _bindings.CreateLazyMarshaler(TestArray2{}) |
| |
| func (msg *TestArray2) Marshaler() _bindings.Marshaler { |
| return _mTestArray2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray2) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray2) InlineSize() int { |
| return 16 |
| } |
| |
| type TestArray3 struct { |
| _ struct{} `fidl2:"s,24,8"` |
| A int32 |
| B [3]uint16 |
| C uint64 |
| } |
| |
| var _mTestArray3 = _bindings.CreateLazyMarshaler(TestArray3{}) |
| |
| func (msg *TestArray3) Marshaler() _bindings.Marshaler { |
| return _mTestArray3 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray3) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray3) InlineSize() int { |
| return 24 |
| } |
| |
| type TestArray4 struct { |
| _ struct{} `fidl2:"s,9,1"` |
| A [9]bool |
| } |
| |
| var _mTestArray4 = _bindings.CreateLazyMarshaler(TestArray4{}) |
| |
| func (msg *TestArray4) Marshaler() _bindings.Marshaler { |
| return _mTestArray4 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray4) InlineAlignment() int { |
| return 1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestArray4) InlineSize() int { |
| return 9 |
| } |
| |
| type TestString1 struct { |
| _ struct{} `fidl2:"s,32,8"` |
| A string |
| B *string |
| } |
| |
| var _mTestString1 = _bindings.CreateLazyMarshaler(TestString1{}) |
| |
| func (msg *TestString1) Marshaler() _bindings.Marshaler { |
| return _mTestString1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestString1) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestString1) InlineSize() int { |
| return 32 |
| } |
| |
| type TestString2 struct { |
| _ struct{} `fidl2:"s,32,8"` |
| A [2]string |
| } |
| |
| var _mTestString2 = _bindings.CreateLazyMarshaler(TestString2{}) |
| |
| func (msg *TestString2) Marshaler() _bindings.Marshaler { |
| return _mTestString2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestString2) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestString2) InlineSize() int { |
| return 32 |
| } |
| |
| type TestString3 struct { |
| _ struct{} `fidl2:"s,64,8"` |
| A [2]string `fidl:"4" fidl2:"4"` |
| B [2]*string `fidl:"4" fidl2:"4"` |
| } |
| |
| var _mTestString3 = _bindings.CreateLazyMarshaler(TestString3{}) |
| |
| func (msg *TestString3) Marshaler() _bindings.Marshaler { |
| return _mTestString3 |
| } |
| |
| // Implements Payload. |
| func (_ *TestString3) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestString3) InlineSize() int { |
| return 64 |
| } |
| |
| type TestVector1 struct { |
| _ struct{} `fidl2:"s,64,8"` |
| A []int8 |
| B *[]int16 |
| C []int32 `fidl:"2" fidl2:"2"` |
| D *[]int64 `fidl:"2" fidl2:"2"` |
| } |
| |
| var _mTestVector1 = _bindings.CreateLazyMarshaler(TestVector1{}) |
| |
| func (msg *TestVector1) Marshaler() _bindings.Marshaler { |
| return _mTestVector1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestVector1) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestVector1) InlineSize() int { |
| return 64 |
| } |
| |
| type TestVector2 struct { |
| _ struct{} `fidl2:"s,64,8"` |
| A [2][]int8 |
| B [][]int8 `fidl:",2" fidl2:"2,"` |
| C []*[]string `fidl:"5,2,2" fidl2:"2,2,5"` |
| } |
| |
| var _mTestVector2 = _bindings.CreateLazyMarshaler(TestVector2{}) |
| |
| func (msg *TestVector2) Marshaler() _bindings.Marshaler { |
| return _mTestVector2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestVector2) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestVector2) InlineSize() int { |
| return 64 |
| } |
| |
| type TestStruct1 struct { |
| _ struct{} `fidl2:"s,16,8"` |
| A TestSimple |
| B *TestSimple |
| } |
| |
| var _mTestStruct1 = _bindings.CreateLazyMarshaler(TestStruct1{}) |
| |
| func (msg *TestStruct1) Marshaler() _bindings.Marshaler { |
| return _mTestStruct1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestStruct1) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestStruct1) InlineSize() int { |
| return 16 |
| } |
| |
| type TestStruct2 struct { |
| _ struct{} `fidl2:"s,88,8"` |
| A TestArray1 |
| B TestFloat1 |
| C TestVector1 |
| D *TestString1 |
| } |
| |
| var _mTestStruct2 = _bindings.CreateLazyMarshaler(TestStruct2{}) |
| |
| func (msg *TestStruct2) Marshaler() _bindings.Marshaler { |
| return _mTestStruct2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestStruct2) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestStruct2) InlineSize() int { |
| return 88 |
| } |
| |
| type TestUnion1 struct { |
| _ struct{} `fidl2:"s,24,8"` |
| A Union1 |
| B *Union1 |
| } |
| |
| var _mTestUnion1 = _bindings.CreateLazyMarshaler(TestUnion1{}) |
| |
| func (msg *TestUnion1) Marshaler() _bindings.Marshaler { |
| return _mTestUnion1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestUnion1) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestUnion1) InlineSize() int { |
| return 24 |
| } |
| |
| type TestUnion2 struct { |
| _ struct{} `fidl2:"s,32,8"` |
| A []Union1 |
| B []*Union1 |
| } |
| |
| var _mTestUnion2 = _bindings.CreateLazyMarshaler(TestUnion2{}) |
| |
| func (msg *TestUnion2) Marshaler() _bindings.Marshaler { |
| return _mTestUnion2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestUnion2) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestUnion2) InlineSize() int { |
| return 32 |
| } |
| |
| type TestHandle1 struct { |
| _ struct{} `fidl2:"s,16,4"` |
| A _zx.Handle `fidl2:"0"` |
| B _zx.Handle `fidl:"*" fidl2:"1"` |
| C _zx.VMO `fidl2:"0"` |
| D _zx.VMO `fidl:"*" fidl2:"1"` |
| } |
| |
| var _mTestHandle1 = _bindings.CreateLazyMarshaler(TestHandle1{}) |
| |
| func (msg *TestHandle1) Marshaler() _bindings.Marshaler { |
| return _mTestHandle1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestHandle1) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *TestHandle1) InlineSize() int { |
| return 16 |
| } |
| |
| type TestHandle2 struct { |
| _ struct{} `fidl2:"s,32,8"` |
| A []_zx.Handle `fidl:"1" fidl2:"1,0"` |
| B []_zx.VMO `fidl:"*,1" fidl2:"1,1"` |
| } |
| |
| var _mTestHandle2 = _bindings.CreateLazyMarshaler(TestHandle2{}) |
| |
| func (msg *TestHandle2) Marshaler() _bindings.Marshaler { |
| return _mTestHandle2 |
| } |
| |
| // Implements Payload. |
| func (_ *TestHandle2) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestHandle2) InlineSize() int { |
| return 32 |
| } |
| |
| type TestInterface1 struct { |
| _ struct{} `fidl2:"s,16,4"` |
| A Test1Interface |
| B Test1Interface `fidl:"*"` |
| C Test1InterfaceRequest `fidl2:"0"` |
| D Test1InterfaceRequest `fidl:"*" fidl2:"1"` |
| } |
| |
| var _mTestInterface1 = _bindings.CreateLazyMarshaler(TestInterface1{}) |
| |
| func (msg *TestInterface1) Marshaler() _bindings.Marshaler { |
| return _mTestInterface1 |
| } |
| |
| // Implements Payload. |
| func (_ *TestInterface1) InlineAlignment() int { |
| return 4 |
| } |
| |
| // Implements Payload. |
| func (_ *TestInterface1) InlineSize() int { |
| return 16 |
| } |
| |
| type TestSimpleTable struct { |
| _ struct{} `fidl2:"s,16,8"` |
| Table SimpleTable |
| } |
| |
| var _mTestSimpleTable = _bindings.CreateLazyMarshaler(TestSimpleTable{}) |
| |
| func (msg *TestSimpleTable) Marshaler() _bindings.Marshaler { |
| return _mTestSimpleTable |
| } |
| |
| // Implements Payload. |
| func (_ *TestSimpleTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestSimpleTable) InlineSize() int { |
| return 16 |
| } |
| |
| type TestOlderSimpleTable struct { |
| _ struct{} `fidl2:"s,16,8"` |
| Table OlderSimpleTable |
| } |
| |
| var _mTestOlderSimpleTable = _bindings.CreateLazyMarshaler(TestOlderSimpleTable{}) |
| |
| func (msg *TestOlderSimpleTable) Marshaler() _bindings.Marshaler { |
| return _mTestOlderSimpleTable |
| } |
| |
| // Implements Payload. |
| func (_ *TestOlderSimpleTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestOlderSimpleTable) InlineSize() int { |
| return 16 |
| } |
| |
| type TestOptSimpleTable struct { |
| _ struct{} `fidl2:"s,8,8"` |
| OptTable *SimpleTable |
| } |
| |
| var _mTestOptSimpleTable = _bindings.CreateLazyMarshaler(TestOptSimpleTable{}) |
| |
| func (msg *TestOptSimpleTable) Marshaler() _bindings.Marshaler { |
| return _mTestOptSimpleTable |
| } |
| |
| // Implements Payload. |
| func (_ *TestOptSimpleTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestOptSimpleTable) InlineSize() int { |
| return 8 |
| } |
| |
| type TestNewerSimpleTable struct { |
| _ struct{} `fidl2:"s,16,8"` |
| Table NewerSimpleTable |
| } |
| |
| var _mTestNewerSimpleTable = _bindings.CreateLazyMarshaler(TestNewerSimpleTable{}) |
| |
| func (msg *TestNewerSimpleTable) Marshaler() _bindings.Marshaler { |
| return _mTestNewerSimpleTable |
| } |
| |
| // Implements Payload. |
| func (_ *TestNewerSimpleTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestNewerSimpleTable) InlineSize() int { |
| return 16 |
| } |
| |
| type TestFuchsiaIoReadAtResponse struct { |
| _ struct{} `fidl2:"s,24,8"` |
| S int32 |
| Data []uint8 `fidl:"8192" fidl2:"8192"` |
| } |
| |
| var _mTestFuchsiaIoReadAtResponse = _bindings.CreateLazyMarshaler(TestFuchsiaIoReadAtResponse{}) |
| |
| func (msg *TestFuchsiaIoReadAtResponse) Marshaler() _bindings.Marshaler { |
| return _mTestFuchsiaIoReadAtResponse |
| } |
| |
| // Implements Payload. |
| func (_ *TestFuchsiaIoReadAtResponse) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFuchsiaIoReadAtResponse) InlineSize() int { |
| return 24 |
| } |
| |
| type TestFuchsiaIoWriteAtRequest struct { |
| _ struct{} `fidl2:"s,24,8"` |
| Data []uint8 `fidl:"8192" fidl2:"8192"` |
| Offset uint64 |
| } |
| |
| var _mTestFuchsiaIoWriteAtRequest = _bindings.CreateLazyMarshaler(TestFuchsiaIoWriteAtRequest{}) |
| |
| func (msg *TestFuchsiaIoWriteAtRequest) Marshaler() _bindings.Marshaler { |
| return _mTestFuchsiaIoWriteAtRequest |
| } |
| |
| // Implements Payload. |
| func (_ *TestFuchsiaIoWriteAtRequest) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestFuchsiaIoWriteAtRequest) InlineSize() int { |
| return 24 |
| } |
| |
| type Union1Tag uint32 |
| |
| const ( |
| _ Union1Tag = iota |
| Union1A |
| Union1B |
| Union1C |
| Union1D |
| ) |
| |
| // Union1 is a FIDL union. |
| type Union1 struct { |
| Union1Tag `fidl:"tag" fidl2:"u,16,8"` |
| A [3]int8 |
| B TestSimple |
| C *TestSimple |
| D float32 |
| } |
| |
| // Implements Payload. |
| func (_ *Union1) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *Union1) InlineSize() int { |
| return 16 |
| } |
| |
| func (u *Union1) Which() Union1Tag { |
| return u.Union1Tag |
| } |
| |
| func (u *Union1) SetA(a [3]int8) { |
| u.Union1Tag = Union1A |
| u.A = a |
| } |
| |
| func (u *Union1) SetB(b TestSimple) { |
| u.Union1Tag = Union1B |
| u.B = b |
| } |
| |
| func (u *Union1) SetC(c *TestSimple) { |
| u.Union1Tag = Union1C |
| u.C = c |
| } |
| |
| func (u *Union1) SetD(d float32) { |
| u.Union1Tag = Union1D |
| u.D = d |
| } |
| |
| type SimpleTable struct { |
| _ struct{} `fidl2:"t,16,8"` |
| X int64 `fidl:"1" fidl2:"1"` |
| XPresent bool |
| Y int64 `fidl:"5" fidl2:"5"` |
| YPresent bool |
| } |
| |
| // Implements Payload. |
| func (_ *SimpleTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *SimpleTable) InlineSize() int { |
| return 16 |
| } |
| |
| func (u *SimpleTable) SetX(x int64) { |
| u.X = x |
| u.XPresent = true |
| } |
| |
| func (u *SimpleTable) GetX() int64 { |
| return u.X |
| } |
| |
| func (u *SimpleTable) HasX() bool { |
| return u.XPresent |
| } |
| |
| func (u *SimpleTable) ClearX() { |
| u.XPresent = false |
| } |
| |
| func (u *SimpleTable) SetY(y int64) { |
| u.Y = y |
| u.YPresent = true |
| } |
| |
| func (u *SimpleTable) GetY() int64 { |
| return u.Y |
| } |
| |
| func (u *SimpleTable) HasY() bool { |
| return u.YPresent |
| } |
| |
| func (u *SimpleTable) ClearY() { |
| u.YPresent = false |
| } |
| |
| type OlderSimpleTable struct { |
| _ struct{} `fidl2:"t,16,8"` |
| X int64 `fidl:"1" fidl2:"1"` |
| XPresent bool |
| } |
| |
| // Implements Payload. |
| func (_ *OlderSimpleTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *OlderSimpleTable) InlineSize() int { |
| return 16 |
| } |
| |
| func (u *OlderSimpleTable) SetX(x int64) { |
| u.X = x |
| u.XPresent = true |
| } |
| |
| func (u *OlderSimpleTable) GetX() int64 { |
| return u.X |
| } |
| |
| func (u *OlderSimpleTable) HasX() bool { |
| return u.XPresent |
| } |
| |
| func (u *OlderSimpleTable) ClearX() { |
| u.XPresent = false |
| } |
| |
| type NewerSimpleTable struct { |
| _ struct{} `fidl2:"t,16,8"` |
| X int64 `fidl:"1" fidl2:"1"` |
| XPresent bool |
| Y int64 `fidl:"5" fidl2:"5"` |
| YPresent bool |
| Z int64 `fidl:"6" fidl2:"6"` |
| ZPresent bool |
| } |
| |
| // Implements Payload. |
| func (_ *NewerSimpleTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *NewerSimpleTable) InlineSize() int { |
| return 16 |
| } |
| |
| func (u *NewerSimpleTable) SetX(x int64) { |
| u.X = x |
| u.XPresent = true |
| } |
| |
| func (u *NewerSimpleTable) GetX() int64 { |
| return u.X |
| } |
| |
| func (u *NewerSimpleTable) HasX() bool { |
| return u.XPresent |
| } |
| |
| func (u *NewerSimpleTable) ClearX() { |
| u.XPresent = false |
| } |
| |
| func (u *NewerSimpleTable) SetY(y int64) { |
| u.Y = y |
| u.YPresent = true |
| } |
| |
| func (u *NewerSimpleTable) GetY() int64 { |
| return u.Y |
| } |
| |
| func (u *NewerSimpleTable) HasY() bool { |
| return u.YPresent |
| } |
| |
| func (u *NewerSimpleTable) ClearY() { |
| u.YPresent = false |
| } |
| |
| func (u *NewerSimpleTable) SetZ(z int64) { |
| u.Z = z |
| u.ZPresent = true |
| } |
| |
| func (u *NewerSimpleTable) GetZ() int64 { |
| return u.Z |
| } |
| |
| func (u *NewerSimpleTable) HasZ() bool { |
| return u.ZPresent |
| } |
| |
| func (u *NewerSimpleTable) ClearZ() { |
| u.ZPresent = false |
| } |
| |
| const ( |
| Test1EchoOrdinal uint32 = 10 |
| Test1SurpriseOrdinal uint32 = 11 |
| ) |
| |
| // Request for Echo. |
| type Test1EchoRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| In *string |
| } |
| |
| var _mTest1EchoRequest = _bindings.CreateLazyMarshaler(Test1EchoRequest{}) |
| |
| func (msg *Test1EchoRequest) Marshaler() _bindings.Marshaler { |
| return _mTest1EchoRequest |
| } |
| |
| // Implements Payload. |
| func (_ *Test1EchoRequest) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *Test1EchoRequest) InlineSize() int { |
| return 16 |
| } |
| |
| // Response for Echo. |
| type Test1EchoResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Out *string |
| } |
| |
| var _mTest1EchoResponse = _bindings.CreateLazyMarshaler(Test1EchoResponse{}) |
| |
| func (msg *Test1EchoResponse) Marshaler() _bindings.Marshaler { |
| return _mTest1EchoResponse |
| } |
| |
| // Implements Payload. |
| func (_ *Test1EchoResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *Test1EchoResponse) InlineSize() int { |
| return 16 |
| } |
| |
| // Request for Surprise. |
| // Surprise has no request. |
| // Response for Surprise. |
| type Test1SurpriseResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Foo string |
| } |
| |
| var _mTest1SurpriseResponse = _bindings.CreateLazyMarshaler(Test1SurpriseResponse{}) |
| |
| func (msg *Test1SurpriseResponse) Marshaler() _bindings.Marshaler { |
| return _mTest1SurpriseResponse |
| } |
| |
| // Implements Payload. |
| func (_ *Test1SurpriseResponse) InlineAlignment() int { |
| return 0 |
| } |
| |
| // Implements Payload. |
| func (_ *Test1SurpriseResponse) InlineSize() int { |
| return 16 |
| } |
| |
| type Test1Interface _bindings.Proxy |
| |
| func (p *Test1Interface) Echo(in *string) (*string, error) { |
| req_ := Test1EchoRequest{ |
| In: in, |
| } |
| resp_ := Test1EchoResponse{} |
| err := ((*_bindings.Proxy)(p)).Call(Test1EchoOrdinal, &req_, &resp_) |
| return resp_.Out, err |
| } |
| func (p *Test1Interface) ExpectSurprise() (string, error) { |
| resp_ := Test1SurpriseResponse{} |
| err := ((*_bindings.Proxy)(p)).Recv(Test1SurpriseOrdinal, &resp_) |
| return resp_.Foo, err |
| } |
| |
| // Test1 server interface. |
| type Test1 interface { |
| Echo(in *string) (*string, error) |
| } |
| |
| type Test1InterfaceRequest _bindings.InterfaceRequest |
| |
| func NewTest1InterfaceRequest() (Test1InterfaceRequest, *Test1Interface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return Test1InterfaceRequest(req), (*Test1Interface)(cli), err |
| } |
| |
| type Test1Stub struct { |
| Impl Test1 |
| } |
| |
| func (s *Test1Stub) Dispatch(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Payload, error) { |
| switch ord { |
| case Test1EchoOrdinal: |
| in_ := Test1EchoRequest{} |
| if err_ := _bindings.Unmarshal(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| out_ := Test1EchoResponse{} |
| out, err_ := s.Impl.Echo(in_.In) |
| out_.Out = out |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| |
| type Test1Service struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *Test1Service) Add(impl Test1, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&Test1Stub{Impl: impl}, c, onError) |
| } |
| |
| func (s *Test1Service) EventProxyFor(key _bindings.BindingKey) (*Test1EventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*Test1EventProxy)(pxy), err |
| } |
| |
| type Test1EventProxy _bindings.Proxy |
| |
| func (p *Test1EventProxy) Surprise(foo string) error { |
| event_ := Test1SurpriseResponse{ |
| Foo: foo, |
| } |
| return ((*_bindings.Proxy)(p)).Send(Test1SurpriseOrdinal, &event_) |
| } |