| // 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. |
| // |
| // GENERATED FILE: Do not edit! |
| // |
| // To rebuild this file, invoke third_party/go/regen-fidl. |
| |
| // +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 TestStringWithBound struct { |
| _ struct{} `fidl2:"s,16,8"` |
| A string `fidl:"8" fidl2:"8"` |
| } |
| |
| var _mTestStringWithBound = _bindings.CreateLazyMarshaler(TestStringWithBound{}) |
| |
| func (msg *TestStringWithBound) Marshaler() _bindings.Marshaler { |
| return _mTestStringWithBound |
| } |
| |
| // Implements Payload. |
| func (_ *TestStringWithBound) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestStringWithBound) InlineSize() int { |
| return 16 |
| } |
| |
| type TestOptStringWithBound struct { |
| _ struct{} `fidl2:"s,16,8"` |
| A *string `fidl:"8" fidl2:"8"` |
| } |
| |
| var _mTestOptStringWithBound = _bindings.CreateLazyMarshaler(TestOptStringWithBound{}) |
| |
| func (msg *TestOptStringWithBound) Marshaler() _bindings.Marshaler { |
| return _mTestOptStringWithBound |
| } |
| |
| // Implements Payload. |
| func (_ *TestOptStringWithBound) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestOptStringWithBound) InlineSize() int { |
| return 16 |
| } |
| |
| 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 EmptyStruct struct { |
| _ struct{} `fidl2:"s,1,1"` |
| } |
| |
| var _mEmptyStruct = _bindings.CreateLazyMarshaler(EmptyStruct{}) |
| |
| func (msg *EmptyStruct) Marshaler() _bindings.Marshaler { |
| return _mEmptyStruct |
| } |
| |
| // Implements Payload. |
| func (_ *EmptyStruct) InlineAlignment() int { |
| return 1 |
| } |
| |
| // Implements Payload. |
| func (_ *EmptyStruct) InlineSize() int { |
| return 1 |
| } |
| |
| type TestEmptyStructSandwich struct { |
| _ struct{} `fidl2:"s,40,8"` |
| Before string |
| Es EmptyStruct |
| After string |
| } |
| |
| var _mTestEmptyStructSandwich = _bindings.CreateLazyMarshaler(TestEmptyStructSandwich{}) |
| |
| func (msg *TestEmptyStructSandwich) Marshaler() _bindings.Marshaler { |
| return _mTestEmptyStructSandwich |
| } |
| |
| // Implements Payload. |
| func (_ *TestEmptyStructSandwich) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestEmptyStructSandwich) InlineSize() int { |
| return 40 |
| } |
| |
| 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 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 TestTableWithStringAndVector struct { |
| _ struct{} `fidl2:"s,16,8"` |
| Table TableWithStringAndVector |
| } |
| |
| var _mTestTableWithStringAndVector = _bindings.CreateLazyMarshaler(TestTableWithStringAndVector{}) |
| |
| func (msg *TestTableWithStringAndVector) Marshaler() _bindings.Marshaler { |
| return _mTestTableWithStringAndVector |
| } |
| |
| // Implements Payload. |
| func (_ *TestTableWithStringAndVector) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestTableWithStringAndVector) InlineSize() int { |
| return 16 |
| } |
| |
| type Int64Struct struct { |
| _ struct{} `fidl2:"s,8,8"` |
| X int64 |
| } |
| |
| var _mInt64Struct = _bindings.CreateLazyMarshaler(Int64Struct{}) |
| |
| func (msg *Int64Struct) Marshaler() _bindings.Marshaler { |
| return _mInt64Struct |
| } |
| |
| // Implements Payload. |
| func (_ *Int64Struct) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *Int64Struct) InlineSize() int { |
| return 8 |
| } |
| |
| type TestInlineXUnionInStruct struct { |
| _ struct{} `fidl2:"s,56,8"` |
| Before string |
| Xu SampleXUnion |
| After string |
| } |
| |
| var _mTestInlineXUnionInStruct = _bindings.CreateLazyMarshaler(TestInlineXUnionInStruct{}) |
| |
| func (msg *TestInlineXUnionInStruct) Marshaler() _bindings.Marshaler { |
| return _mTestInlineXUnionInStruct |
| } |
| |
| // Implements Payload. |
| func (_ *TestInlineXUnionInStruct) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestInlineXUnionInStruct) InlineSize() int { |
| return 56 |
| } |
| |
| type TestOptionalXUnionInStruct struct { |
| _ struct{} `fidl2:"s,56,8"` |
| Before string |
| Xu *SampleXUnion |
| After string |
| } |
| |
| var _mTestOptionalXUnionInStruct = _bindings.CreateLazyMarshaler(TestOptionalXUnionInStruct{}) |
| |
| func (msg *TestOptionalXUnionInStruct) Marshaler() _bindings.Marshaler { |
| return _mTestOptionalXUnionInStruct |
| } |
| |
| // Implements Payload. |
| func (_ *TestOptionalXUnionInStruct) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestOptionalXUnionInStruct) InlineSize() int { |
| return 56 |
| } |
| |
| type TestXUnionInTable struct { |
| _ struct{} `fidl2:"s,16,8"` |
| Value XUnionInTable |
| } |
| |
| var _mTestXUnionInTable = _bindings.CreateLazyMarshaler(TestXUnionInTable{}) |
| |
| func (msg *TestXUnionInTable) Marshaler() _bindings.Marshaler { |
| return _mTestXUnionInTable |
| } |
| |
| // Implements Payload. |
| func (_ *TestXUnionInTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TestXUnionInTable) 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 |
| ) |
| |
| 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 SimpleUnionTag uint32 |
| |
| const ( |
| _ SimpleUnionTag = iota |
| SimpleUnionI32 |
| SimpleUnionI64 |
| SimpleUnionS |
| SimpleUnionOs |
| SimpleUnionStr |
| ) |
| |
| type SimpleUnion struct { |
| SimpleUnionTag `fidl:"tag" fidl2:"u,24,8"` |
| I32 int32 |
| I64 int64 |
| S Int64Struct |
| Os *Int64Struct |
| Str string |
| } |
| |
| // Implements Payload. |
| func (_ *SimpleUnion) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *SimpleUnion) InlineSize() int { |
| return 24 |
| } |
| |
| func (u *SimpleUnion) Which() SimpleUnionTag { |
| return u.SimpleUnionTag |
| } |
| |
| func (u *SimpleUnion) SetI32(i32 int32) { |
| u.SimpleUnionTag = SimpleUnionI32 |
| u.I32 = i32 |
| } |
| |
| func (u *SimpleUnion) SetI64(i64 int64) { |
| u.SimpleUnionTag = SimpleUnionI64 |
| u.I64 = i64 |
| } |
| |
| func (u *SimpleUnion) SetS(s Int64Struct) { |
| u.SimpleUnionTag = SimpleUnionS |
| u.S = s |
| } |
| |
| func (u *SimpleUnion) SetOs(os *Int64Struct) { |
| u.SimpleUnionTag = SimpleUnionOs |
| u.Os = os |
| } |
| |
| func (u *SimpleUnion) SetStr(str string) { |
| u.SimpleUnionTag = SimpleUnionStr |
| u.Str = str |
| } |
| |
| type SampleXUnionTag uint32 |
| |
| const ( |
| SampleXUnionU = 2039012153 // 0x7988db39 |
| SampleXUnionSu = 1050654350 // 0x3e9fb68e |
| SampleXUnionSt = 1086116147 // 0x40bcd133 |
| ) |
| |
| type SampleXUnion struct { |
| SampleXUnionTag `fidl2:"x,24,8"` |
| U uint32 `fidl:"2039012153" fidl2:"2039012153"` |
| Su SimpleUnion `fidl:"1050654350" fidl2:"1050654350"` |
| St SimpleTable `fidl:"1086116147" fidl2:"1086116147"` |
| } |
| |
| // Implements Payload. |
| func (_ *SampleXUnion) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *SampleXUnion) InlineSize() int { |
| return 24 |
| } |
| |
| func (_m *SampleXUnion) Which() SampleXUnionTag { |
| return _m.SampleXUnionTag |
| } |
| |
| func (_m *SampleXUnion) SetU(u uint32) { |
| _m.SampleXUnionTag = SampleXUnionU |
| _m.U = u |
| } |
| |
| func (_m *SampleXUnion) SetSu(su SimpleUnion) { |
| _m.SampleXUnionTag = SampleXUnionSu |
| _m.Su = su |
| } |
| |
| func (_m *SampleXUnion) SetSt(st SimpleTable) { |
| _m.SampleXUnionTag = SampleXUnionSt |
| _m.St = st |
| } |
| |
| 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 |
| } |
| |
| type TableWithStringAndVector struct { |
| _ struct{} `fidl2:"t,16,8"` |
| Foo string `fidl:",1" fidl2:"1,"` |
| FooPresent bool |
| Bar int32 `fidl:"2" fidl2:"2"` |
| BarPresent bool |
| Baz []uint8 `fidl:",3" fidl2:"3,"` |
| BazPresent bool |
| } |
| |
| // Implements Payload. |
| func (_ *TableWithStringAndVector) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *TableWithStringAndVector) InlineSize() int { |
| return 16 |
| } |
| |
| func (u *TableWithStringAndVector) SetFoo(foo string) { |
| u.Foo = foo |
| u.FooPresent = true |
| } |
| |
| func (u *TableWithStringAndVector) GetFoo() string { |
| return u.Foo |
| } |
| |
| func (u *TableWithStringAndVector) HasFoo() bool { |
| return u.FooPresent |
| } |
| |
| func (u *TableWithStringAndVector) ClearFoo() { |
| u.FooPresent = false |
| } |
| |
| func (u *TableWithStringAndVector) SetBar(bar int32) { |
| u.Bar = bar |
| u.BarPresent = true |
| } |
| |
| func (u *TableWithStringAndVector) GetBar() int32 { |
| return u.Bar |
| } |
| |
| func (u *TableWithStringAndVector) HasBar() bool { |
| return u.BarPresent |
| } |
| |
| func (u *TableWithStringAndVector) ClearBar() { |
| u.BarPresent = false |
| } |
| |
| func (u *TableWithStringAndVector) SetBaz(baz []uint8) { |
| u.Baz = baz |
| u.BazPresent = true |
| } |
| |
| func (u *TableWithStringAndVector) GetBaz() []uint8 { |
| return u.Baz |
| } |
| |
| func (u *TableWithStringAndVector) HasBaz() bool { |
| return u.BazPresent |
| } |
| |
| func (u *TableWithStringAndVector) ClearBaz() { |
| u.BazPresent = false |
| } |
| |
| type XUnionInTable struct { |
| _ struct{} `fidl2:"t,16,8"` |
| Before string `fidl:",1" fidl2:"1,"` |
| BeforePresent bool |
| Xu SampleXUnion `fidl:"2" fidl2:"2"` |
| XuPresent bool |
| After string `fidl:",3" fidl2:"3,"` |
| AfterPresent bool |
| } |
| |
| // Implements Payload. |
| func (_ *XUnionInTable) InlineAlignment() int { |
| return 8 |
| } |
| |
| // Implements Payload. |
| func (_ *XUnionInTable) InlineSize() int { |
| return 16 |
| } |
| |
| func (u *XUnionInTable) SetBefore(before string) { |
| u.Before = before |
| u.BeforePresent = true |
| } |
| |
| func (u *XUnionInTable) GetBefore() string { |
| return u.Before |
| } |
| |
| func (u *XUnionInTable) HasBefore() bool { |
| return u.BeforePresent |
| } |
| |
| func (u *XUnionInTable) ClearBefore() { |
| u.BeforePresent = false |
| } |
| |
| func (u *XUnionInTable) SetXu(xu SampleXUnion) { |
| u.Xu = xu |
| u.XuPresent = true |
| } |
| |
| func (u *XUnionInTable) GetXu() SampleXUnion { |
| return u.Xu |
| } |
| |
| func (u *XUnionInTable) HasXu() bool { |
| return u.XuPresent |
| } |
| |
| func (u *XUnionInTable) ClearXu() { |
| u.XuPresent = false |
| } |
| |
| func (u *XUnionInTable) SetAfter(after string) { |
| u.After = after |
| u.AfterPresent = true |
| } |
| |
| func (u *XUnionInTable) GetAfter() string { |
| return u.After |
| } |
| |
| func (u *XUnionInTable) HasAfter() bool { |
| return u.AfterPresent |
| } |
| |
| func (u *XUnionInTable) ClearAfter() { |
| u.AfterPresent = false |
| } |
| |
| const ( |
| Test1EchoOrdinal uint32 = 1246312959 |
| Test1EchoGenOrdinal uint32 = 1246312959 |
| Test1SurpriseOrdinal uint32 = 1272344178 |
| Test1SurpriseGenOrdinal uint32 = 1272344178 |
| ) |
| |
| 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 |
| } |
| |
| 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 |
| } |
| |
| 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.ChannelProxy |
| |
| func (p *Test1Interface) Echo(in *string) (*string, error) { |
| req_ := &Test1EchoRequest{ |
| In: in, |
| } |
| resp_ := &Test1EchoResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Call(Test1EchoOrdinal, req_, resp_) |
| return resp_.Out, err |
| } |
| |
| func (p *Test1Interface) ExpectSurprise() (string, error) { |
| resp_ := &Test1SurpriseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).Recv(Test1SurpriseOrdinal, resp_) |
| return resp_.Foo, err |
| } |
| |
| type Test1 interface { |
| Echo(in *string) (*string, error) |
| } |
| |
| type Test1TransitionalBase struct{} |
| |
| 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, err_ := s.Impl.Echo(in_.In) |
| out_ := Test1EchoResponse{} |
| 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.ChannelProxy |
| |
| func (p *Test1EventProxy) Surprise(foo string) error { |
| event_ := &Test1SurpriseResponse{ |
| Foo: foo, |
| } |
| return ((*_bindings.ChannelProxy)(p)).Send(Test1SurpriseOrdinal, event_) |
| } |
