| // WARNING: This file is machine generated by fidlgen. |
| |
| // fidl_experiment = output_index_json |
| |
| package typesinprotocols |
| |
| import ( |
| _strings "strings" |
| _zx "syscall/zx" |
| _bindings "syscall/zx/fidl" |
| ) |
| |
| var _ _bindings.Enum = Enum(0) |
| |
| type Enum uint32 |
| |
| const ( |
| EnumVal Enum = 1 |
| |
| // Enum_Unknown is the default unknown placeholder. |
| Enum_Unknown Enum = 0xffffffff |
| ) |
| |
| func (_ Enum) I_EnumValues() []Enum { |
| return []Enum{ |
| EnumVal, |
| } |
| } |
| |
| func (_ Enum) I_EnumIsStrict() bool { |
| return false |
| } |
| |
| func (x Enum) IsUnknown() bool { |
| switch x { |
| case 1: |
| return false |
| } |
| return true |
| } |
| |
| func (x Enum) String() string { |
| switch x { |
| case 1: |
| return "Val" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Bits = Bits(0) |
| |
| type Bits uint32 |
| |
| const ( |
| BitsVal Bits = 1 |
| Bits_Mask Bits = 1 |
| ) |
| |
| func (_ Bits) I_BitsMask() Bits { |
| return Bits_Mask |
| } |
| |
| func (_ Bits) I_BitsIsStrict() bool { |
| return false |
| } |
| |
| func (x Bits) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x Bits) GetUnknownBits() uint64 { |
| return uint64(^Bits_Mask & x) |
| } |
| |
| func (x Bits) InvertBits() Bits { |
| return Bits_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x Bits) HasBits(mask Bits) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x Bits) ClearBits(mask Bits) Bits { |
| return ^mask & x |
| } |
| |
| func (x Bits) String() string { |
| var buf _strings.Builder |
| if 1&x != 0 { |
| if buf.Len() != 0 { |
| buf.WriteRune('|') |
| } |
| buf.WriteString("Val") |
| } |
| if buf.Len() == 0 { |
| buf.WriteString("<empty bits>") |
| } |
| return buf.String() |
| } |
| |
| type ArrayBasic struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"384" fidl_alignment_v2:"8"` |
| ArrayUint8 [5]uint8 `fidl_offset_v2:"0"` |
| ArrayUint16 [5]uint16 `fidl_offset_v2:"6"` |
| ArrayUint32 [5]uint32 `fidl_offset_v2:"16"` |
| ArrayUint64 [5]uint64 `fidl_offset_v2:"40"` |
| ArrayInt8 [5]int8 `fidl_offset_v2:"80"` |
| ArrayInt16 [5]int16 `fidl_offset_v2:"86"` |
| ArrayInt32 [5]int32 `fidl_offset_v2:"96"` |
| ArrayInt64 [5]int64 `fidl_offset_v2:"120"` |
| ArrayFloat32 [5]float32 `fidl_offset_v2:"160"` |
| ArrayFloat64 [5]float64 `fidl_offset_v2:"184"` |
| ArrayString [5]string `fidl_offset_v2:"224" fidl_bounds:""` |
| ArrayOptString [5]*string `fidl_offset_v2:"304" fidl_bounds:""` |
| } |
| |
| var _mArrayBasic = _bindings.CreateLazyMarshaler(ArrayBasic{}) |
| |
| func (msg *ArrayBasic) Marshaler() _bindings.Marshaler { |
| return _mArrayBasic |
| } |
| |
| type ArrayCompound struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"328" fidl_alignment_v2:"8"` |
| ArrayBits [5]Bits `fidl_offset_v2:"0"` |
| ArrayEnum [5]Enum `fidl_offset_v2:"20"` |
| ArrayStruct [5]Struct `fidl_offset_v2:"40"` |
| ArrayTable [5]Table `fidl_offset_v2:"48"` |
| ArrayUnion [5]Union `fidl_offset_v2:"128"` |
| ArrayOptStruct [5]*Struct `fidl_offset_v2:"208"` |
| ArrayOptUnion [5]*Union `fidl_offset_v2:"248"` |
| } |
| |
| var _mArrayCompound = _bindings.CreateLazyMarshaler(ArrayCompound{}) |
| |
| func (msg *ArrayCompound) Marshaler() _bindings.Marshaler { |
| return _mArrayCompound |
| } |
| |
| type ArrayVectorNested struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"144" fidl_alignment_v2:"8"` |
| ArrayArrayUint8 [5][5]uint8 `fidl_offset_v2:"0"` |
| ArrayVectorUint8 [5][]uint8 `fidl_offset_v2:"32" fidl_bounds:""` |
| VectorArrayUint8 [][5]uint8 `fidl_offset_v2:"112" fidl_bounds:""` |
| VectorVectorUint8 [][]uint8 `fidl_offset_v2:"128" fidl_bounds:""` |
| } |
| |
| var _mArrayVectorNested = _bindings.CreateLazyMarshaler(ArrayVectorNested{}) |
| |
| func (msg *ArrayVectorNested) Marshaler() _bindings.Marshaler { |
| return _mArrayVectorNested |
| } |
| |
| type Basic struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"80" fidl_alignment_v2:"8"` |
| Uint8 uint8 `fidl_offset_v2:"0"` |
| Uint16 uint16 `fidl_offset_v2:"2"` |
| Uint32 uint32 `fidl_offset_v2:"4"` |
| Uint64 uint64 `fidl_offset_v2:"8"` |
| Int8 int8 `fidl_offset_v2:"16"` |
| Int16 int16 `fidl_offset_v2:"18"` |
| Int32 int32 `fidl_offset_v2:"20"` |
| Int64 int64 `fidl_offset_v2:"24"` |
| Float32 float32 `fidl_offset_v2:"32"` |
| Float64 float64 `fidl_offset_v2:"40"` |
| String string `fidl_offset_v2:"48" fidl_bounds:""` |
| OptString *string `fidl_offset_v2:"64" fidl_bounds:""` |
| } |
| |
| var _mBasic = _bindings.CreateLazyMarshaler(Basic{}) |
| |
| func (msg *Basic) Marshaler() _bindings.Marshaler { |
| return _mBasic |
| } |
| |
| type Compound struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"72" fidl_alignment_v2:"8"` |
| Bits Bits `fidl_offset_v2:"0"` |
| Enum Enum `fidl_offset_v2:"4"` |
| Struct Struct `fidl_offset_v2:"8"` |
| Table Table `fidl_offset_v2:"16"` |
| Union Union `fidl_offset_v2:"32"` |
| OptStruct *Struct `fidl_offset_v2:"48"` |
| OptUnion *Union `fidl_offset_v2:"56"` |
| } |
| |
| var _mCompound = _bindings.CreateLazyMarshaler(Compound{}) |
| |
| func (msg *Compound) Marshaler() _bindings.Marshaler { |
| return _mCompound |
| } |
| |
| type Resource struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"456" fidl_alignment_v2:"8"` |
| Handle _zx.Handle `fidl_offset_v2:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"` |
| Vmo _zx.VMO `fidl_offset_v2:"4" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"0"` |
| ClientEnd ProtocolWithCtxInterface `fidl_offset_v2:"8" fidl_handle_subtype:"4"` |
| ServerEnd ProtocolWithCtxInterfaceRequest `fidl_offset_v2:"12" fidl_handle_subtype:"4" fidl_bounds:"0"` |
| Struct ResourceStruct `fidl_offset_v2:"16"` |
| Table ResourceTable `fidl_offset_v2:"24"` |
| Union ResourceUnion `fidl_offset_v2:"40"` |
| OptHandle _zx.Handle `fidl_offset_v2:"56" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"1"` |
| OptVmo _zx.VMO `fidl_offset_v2:"60" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"1"` |
| OptClientEnd ProtocolWithCtxInterface `fidl_offset_v2:"64" fidl_handle_subtype:"4"` |
| OptServerEnd ProtocolWithCtxInterfaceRequest `fidl_offset_v2:"68" fidl_handle_subtype:"4" fidl_bounds:"1"` |
| OptStruct *ResourceStruct `fidl_offset_v2:"72"` |
| OptUnion *ResourceUnion `fidl_offset_v2:"80"` |
| ArrayHandle [5]_zx.Handle `fidl_offset_v2:"96" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"` |
| ArrayVmo [5]_zx.VMO `fidl_offset_v2:"116" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:"0"` |
| ArrayClientEnd [5]ProtocolWithCtxInterface `fidl_offset_v2:"136" fidl_handle_subtype:"4"` |
| ArrayServerEnd [5]ProtocolWithCtxInterfaceRequest `fidl_offset_v2:"156" fidl_handle_subtype:"4" fidl_bounds:"0"` |
| ArrayStruct [5]ResourceStruct `fidl_offset_v2:"176"` |
| ArrayTable [5]ResourceTable `fidl_offset_v2:"184"` |
| ArrayUnion [5]ResourceUnion `fidl_offset_v2:"264"` |
| VectorHandle []_zx.Handle `fidl_offset_v2:"344" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:",0"` |
| VectorVmo []_zx.VMO `fidl_offset_v2:"360" fidl_handle_subtype:"3" fidl_handle_rights:"2147483648" fidl_bounds:",0"` |
| VectorClientEnd []ProtocolWithCtxInterface `fidl_offset_v2:"376" fidl_handle_subtype:"4" fidl_bounds:""` |
| VectorServerEnd []ProtocolWithCtxInterfaceRequest `fidl_offset_v2:"392" fidl_handle_subtype:"4" fidl_bounds:",0"` |
| VectorStruct []ResourceStruct `fidl_offset_v2:"408" fidl_bounds:""` |
| VectorTable []ResourceTable `fidl_offset_v2:"424" fidl_bounds:""` |
| VectorUnion []ResourceUnion `fidl_offset_v2:"440" fidl_bounds:""` |
| } |
| |
| var _mResource = _bindings.CreateLazyMarshaler(Resource{}) |
| |
| func (msg *Resource) Marshaler() _bindings.Marshaler { |
| return _mResource |
| } |
| |
| type ResourceStruct struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mResourceStruct = _bindings.CreateLazyMarshaler(ResourceStruct{}) |
| |
| func (msg *ResourceStruct) Marshaler() _bindings.Marshaler { |
| return _mResourceStruct |
| } |
| |
| type Struct struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"1" fidl_alignment_v2:"1"` |
| } |
| |
| var _mStruct = _bindings.CreateLazyMarshaler(Struct{}) |
| |
| func (msg *Struct) Marshaler() _bindings.Marshaler { |
| return _mStruct |
| } |
| |
| type VectorBasic struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"192" fidl_alignment_v2:"8"` |
| VectorUint8 []uint8 `fidl_offset_v2:"0" fidl_bounds:""` |
| VectorUint16 []uint16 `fidl_offset_v2:"16" fidl_bounds:""` |
| VectorUint32 []uint32 `fidl_offset_v2:"32" fidl_bounds:""` |
| VectorUint64 []uint64 `fidl_offset_v2:"48" fidl_bounds:""` |
| VectorInt8 []int8 `fidl_offset_v2:"64" fidl_bounds:""` |
| VectorInt16 []int16 `fidl_offset_v2:"80" fidl_bounds:""` |
| VectorInt32 []int32 `fidl_offset_v2:"96" fidl_bounds:""` |
| VectorInt64 []int64 `fidl_offset_v2:"112" fidl_bounds:""` |
| VectorFloat32 []float32 `fidl_offset_v2:"128" fidl_bounds:""` |
| VectorFloat64 []float64 `fidl_offset_v2:"144" fidl_bounds:""` |
| VectorString []string `fidl_offset_v2:"160" fidl_bounds:""` |
| VectorOptString []*string `fidl_offset_v2:"176" fidl_bounds:""` |
| } |
| |
| var _mVectorBasic = _bindings.CreateLazyMarshaler(VectorBasic{}) |
| |
| func (msg *VectorBasic) Marshaler() _bindings.Marshaler { |
| return _mVectorBasic |
| } |
| |
| type VectorCompound struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"112" fidl_alignment_v2:"8"` |
| VectorBits []Bits `fidl_offset_v2:"0" fidl_bounds:""` |
| VectorEnum []Enum `fidl_offset_v2:"16" fidl_bounds:""` |
| VectorStruct []Struct `fidl_offset_v2:"32" fidl_bounds:""` |
| VectorTable []Table `fidl_offset_v2:"48" fidl_bounds:""` |
| VectorUnion []Union `fidl_offset_v2:"64" fidl_bounds:""` |
| VectorOptStruct []*Struct `fidl_offset_v2:"80" fidl_bounds:""` |
| VectorOptUnion []*Union `fidl_offset_v2:"96" fidl_bounds:""` |
| } |
| |
| var _mVectorCompound = _bindings.CreateLazyMarshaler(VectorCompound{}) |
| |
| func (msg *VectorCompound) Marshaler() _bindings.Marshaler { |
| return _mVectorCompound |
| } |
| |
| type VectorOptional struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"64" fidl_alignment_v2:"8"` |
| OptVectorUint8 *[]uint8 `fidl_offset_v2:"0" fidl_bounds:""` |
| OptVectorString *[]string `fidl_offset_v2:"16" fidl_bounds:""` |
| OptVectorStruct *[]Struct `fidl_offset_v2:"32" fidl_bounds:""` |
| OptVectorOptStruct *[]*Struct `fidl_offset_v2:"48" fidl_bounds:""` |
| } |
| |
| var _mVectorOptional = _bindings.CreateLazyMarshaler(VectorOptional{}) |
| |
| func (msg *VectorOptional) Marshaler() _bindings.Marshaler { |
| return _mVectorOptional |
| } |
| |
| type I_protocolErrorArrayBasicResultTag uint64 |
| |
| const ( |
| ProtocolErrorArrayBasicResultResponse = 1 // 0x00000001 |
| ProtocolErrorArrayBasicResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorArrayBasicResult struct { |
| I_protocolErrorArrayBasicResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response ArrayBasic `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorArrayBasicResult = _bindings.CreateLazyMarshaler(ProtocolErrorArrayBasicResult{}) |
| |
| func (msg *ProtocolErrorArrayBasicResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorArrayBasicResult |
| } |
| |
| func (_m *ProtocolErrorArrayBasicResult) reset() { |
| switch _m.I_protocolErrorArrayBasicResultTag { |
| case 1: |
| var _zeroed ArrayBasic |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorArrayBasicResult) Which() I_protocolErrorArrayBasicResultTag { |
| return _m.I_protocolErrorArrayBasicResultTag |
| } |
| |
| func (_m *ProtocolErrorArrayBasicResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorArrayBasicResultTag) |
| } |
| |
| func (_m *ProtocolErrorArrayBasicResult) SetResponse(response ArrayBasic) { |
| _m.reset() |
| _m.I_protocolErrorArrayBasicResultTag = ProtocolErrorArrayBasicResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorArrayBasicResultWithResponse(response ArrayBasic) ProtocolErrorArrayBasicResult { |
| var _u ProtocolErrorArrayBasicResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorArrayBasicResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorArrayBasicResultTag = ProtocolErrorArrayBasicResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorArrayBasicResultWithErr(err uint32) ProtocolErrorArrayBasicResult { |
| var _u ProtocolErrorArrayBasicResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorArrayCompoundResultTag uint64 |
| |
| const ( |
| ProtocolErrorArrayCompoundResultResponse = 1 // 0x00000001 |
| ProtocolErrorArrayCompoundResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorArrayCompoundResult struct { |
| I_protocolErrorArrayCompoundResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response ArrayCompound `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorArrayCompoundResult = _bindings.CreateLazyMarshaler(ProtocolErrorArrayCompoundResult{}) |
| |
| func (msg *ProtocolErrorArrayCompoundResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorArrayCompoundResult |
| } |
| |
| func (_m *ProtocolErrorArrayCompoundResult) reset() { |
| switch _m.I_protocolErrorArrayCompoundResultTag { |
| case 1: |
| var _zeroed ArrayCompound |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorArrayCompoundResult) Which() I_protocolErrorArrayCompoundResultTag { |
| return _m.I_protocolErrorArrayCompoundResultTag |
| } |
| |
| func (_m *ProtocolErrorArrayCompoundResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorArrayCompoundResultTag) |
| } |
| |
| func (_m *ProtocolErrorArrayCompoundResult) SetResponse(response ArrayCompound) { |
| _m.reset() |
| _m.I_protocolErrorArrayCompoundResultTag = ProtocolErrorArrayCompoundResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorArrayCompoundResultWithResponse(response ArrayCompound) ProtocolErrorArrayCompoundResult { |
| var _u ProtocolErrorArrayCompoundResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorArrayCompoundResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorArrayCompoundResultTag = ProtocolErrorArrayCompoundResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorArrayCompoundResultWithErr(err uint32) ProtocolErrorArrayCompoundResult { |
| var _u ProtocolErrorArrayCompoundResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorArrayVectorNestedResultTag uint64 |
| |
| const ( |
| ProtocolErrorArrayVectorNestedResultResponse = 1 // 0x00000001 |
| ProtocolErrorArrayVectorNestedResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorArrayVectorNestedResult struct { |
| I_protocolErrorArrayVectorNestedResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response ArrayVectorNested `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorArrayVectorNestedResult = _bindings.CreateLazyMarshaler(ProtocolErrorArrayVectorNestedResult{}) |
| |
| func (msg *ProtocolErrorArrayVectorNestedResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorArrayVectorNestedResult |
| } |
| |
| func (_m *ProtocolErrorArrayVectorNestedResult) reset() { |
| switch _m.I_protocolErrorArrayVectorNestedResultTag { |
| case 1: |
| var _zeroed ArrayVectorNested |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorArrayVectorNestedResult) Which() I_protocolErrorArrayVectorNestedResultTag { |
| return _m.I_protocolErrorArrayVectorNestedResultTag |
| } |
| |
| func (_m *ProtocolErrorArrayVectorNestedResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorArrayVectorNestedResultTag) |
| } |
| |
| func (_m *ProtocolErrorArrayVectorNestedResult) SetResponse(response ArrayVectorNested) { |
| _m.reset() |
| _m.I_protocolErrorArrayVectorNestedResultTag = ProtocolErrorArrayVectorNestedResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorArrayVectorNestedResultWithResponse(response ArrayVectorNested) ProtocolErrorArrayVectorNestedResult { |
| var _u ProtocolErrorArrayVectorNestedResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorArrayVectorNestedResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorArrayVectorNestedResultTag = ProtocolErrorArrayVectorNestedResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorArrayVectorNestedResultWithErr(err uint32) ProtocolErrorArrayVectorNestedResult { |
| var _u ProtocolErrorArrayVectorNestedResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorBasicResultTag uint64 |
| |
| const ( |
| ProtocolErrorBasicResultResponse = 1 // 0x00000001 |
| ProtocolErrorBasicResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorBasicResult struct { |
| I_protocolErrorBasicResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response Basic `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorBasicResult = _bindings.CreateLazyMarshaler(ProtocolErrorBasicResult{}) |
| |
| func (msg *ProtocolErrorBasicResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorBasicResult |
| } |
| |
| func (_m *ProtocolErrorBasicResult) reset() { |
| switch _m.I_protocolErrorBasicResultTag { |
| case 1: |
| var _zeroed Basic |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorBasicResult) Which() I_protocolErrorBasicResultTag { |
| return _m.I_protocolErrorBasicResultTag |
| } |
| |
| func (_m *ProtocolErrorBasicResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorBasicResultTag) |
| } |
| |
| func (_m *ProtocolErrorBasicResult) SetResponse(response Basic) { |
| _m.reset() |
| _m.I_protocolErrorBasicResultTag = ProtocolErrorBasicResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorBasicResultWithResponse(response Basic) ProtocolErrorBasicResult { |
| var _u ProtocolErrorBasicResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorBasicResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorBasicResultTag = ProtocolErrorBasicResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorBasicResultWithErr(err uint32) ProtocolErrorBasicResult { |
| var _u ProtocolErrorBasicResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorCompoundResultTag uint64 |
| |
| const ( |
| ProtocolErrorCompoundResultResponse = 1 // 0x00000001 |
| ProtocolErrorCompoundResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorCompoundResult struct { |
| I_protocolErrorCompoundResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response Compound `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorCompoundResult = _bindings.CreateLazyMarshaler(ProtocolErrorCompoundResult{}) |
| |
| func (msg *ProtocolErrorCompoundResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorCompoundResult |
| } |
| |
| func (_m *ProtocolErrorCompoundResult) reset() { |
| switch _m.I_protocolErrorCompoundResultTag { |
| case 1: |
| var _zeroed Compound |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorCompoundResult) Which() I_protocolErrorCompoundResultTag { |
| return _m.I_protocolErrorCompoundResultTag |
| } |
| |
| func (_m *ProtocolErrorCompoundResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorCompoundResultTag) |
| } |
| |
| func (_m *ProtocolErrorCompoundResult) SetResponse(response Compound) { |
| _m.reset() |
| _m.I_protocolErrorCompoundResultTag = ProtocolErrorCompoundResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorCompoundResultWithResponse(response Compound) ProtocolErrorCompoundResult { |
| var _u ProtocolErrorCompoundResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorCompoundResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorCompoundResultTag = ProtocolErrorCompoundResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorCompoundResultWithErr(err uint32) ProtocolErrorCompoundResult { |
| var _u ProtocolErrorCompoundResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorResourceResultTag uint64 |
| |
| const ( |
| ProtocolErrorResourceResultResponse = 1 // 0x00000001 |
| ProtocolErrorResourceResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorResourceResult struct { |
| I_protocolErrorResourceResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| Response Resource `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorResourceResult = _bindings.CreateLazyMarshaler(ProtocolErrorResourceResult{}) |
| |
| func (msg *ProtocolErrorResourceResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorResourceResult |
| } |
| |
| func (_m *ProtocolErrorResourceResult) reset() { |
| switch _m.I_protocolErrorResourceResultTag { |
| case 1: |
| var _zeroed Resource |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorResourceResult) Which() I_protocolErrorResourceResultTag { |
| return _m.I_protocolErrorResourceResultTag |
| } |
| |
| func (_m *ProtocolErrorResourceResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorResourceResultTag) |
| } |
| |
| func (_m *ProtocolErrorResourceResult) SetResponse(response Resource) { |
| _m.reset() |
| _m.I_protocolErrorResourceResultTag = ProtocolErrorResourceResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorResourceResultWithResponse(response Resource) ProtocolErrorResourceResult { |
| var _u ProtocolErrorResourceResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorResourceResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorResourceResultTag = ProtocolErrorResourceResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorResourceResultWithErr(err uint32) ProtocolErrorResourceResult { |
| var _u ProtocolErrorResourceResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorVectorBasicResultTag uint64 |
| |
| const ( |
| ProtocolErrorVectorBasicResultResponse = 1 // 0x00000001 |
| ProtocolErrorVectorBasicResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorVectorBasicResult struct { |
| I_protocolErrorVectorBasicResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response VectorBasic `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorVectorBasicResult = _bindings.CreateLazyMarshaler(ProtocolErrorVectorBasicResult{}) |
| |
| func (msg *ProtocolErrorVectorBasicResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorVectorBasicResult |
| } |
| |
| func (_m *ProtocolErrorVectorBasicResult) reset() { |
| switch _m.I_protocolErrorVectorBasicResultTag { |
| case 1: |
| var _zeroed VectorBasic |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorVectorBasicResult) Which() I_protocolErrorVectorBasicResultTag { |
| return _m.I_protocolErrorVectorBasicResultTag |
| } |
| |
| func (_m *ProtocolErrorVectorBasicResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorVectorBasicResultTag) |
| } |
| |
| func (_m *ProtocolErrorVectorBasicResult) SetResponse(response VectorBasic) { |
| _m.reset() |
| _m.I_protocolErrorVectorBasicResultTag = ProtocolErrorVectorBasicResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorVectorBasicResultWithResponse(response VectorBasic) ProtocolErrorVectorBasicResult { |
| var _u ProtocolErrorVectorBasicResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorVectorBasicResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorVectorBasicResultTag = ProtocolErrorVectorBasicResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorVectorBasicResultWithErr(err uint32) ProtocolErrorVectorBasicResult { |
| var _u ProtocolErrorVectorBasicResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorVectorCompoundResultTag uint64 |
| |
| const ( |
| ProtocolErrorVectorCompoundResultResponse = 1 // 0x00000001 |
| ProtocolErrorVectorCompoundResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorVectorCompoundResult struct { |
| I_protocolErrorVectorCompoundResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response VectorCompound `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorVectorCompoundResult = _bindings.CreateLazyMarshaler(ProtocolErrorVectorCompoundResult{}) |
| |
| func (msg *ProtocolErrorVectorCompoundResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorVectorCompoundResult |
| } |
| |
| func (_m *ProtocolErrorVectorCompoundResult) reset() { |
| switch _m.I_protocolErrorVectorCompoundResultTag { |
| case 1: |
| var _zeroed VectorCompound |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorVectorCompoundResult) Which() I_protocolErrorVectorCompoundResultTag { |
| return _m.I_protocolErrorVectorCompoundResultTag |
| } |
| |
| func (_m *ProtocolErrorVectorCompoundResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorVectorCompoundResultTag) |
| } |
| |
| func (_m *ProtocolErrorVectorCompoundResult) SetResponse(response VectorCompound) { |
| _m.reset() |
| _m.I_protocolErrorVectorCompoundResultTag = ProtocolErrorVectorCompoundResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorVectorCompoundResultWithResponse(response VectorCompound) ProtocolErrorVectorCompoundResult { |
| var _u ProtocolErrorVectorCompoundResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorVectorCompoundResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorVectorCompoundResultTag = ProtocolErrorVectorCompoundResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorVectorCompoundResultWithErr(err uint32) ProtocolErrorVectorCompoundResult { |
| var _u ProtocolErrorVectorCompoundResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_protocolErrorVectorOptionalResultTag uint64 |
| |
| const ( |
| ProtocolErrorVectorOptionalResultResponse = 1 // 0x00000001 |
| ProtocolErrorVectorOptionalResultErr = 2 // 0x00000002 |
| ) |
| |
| type ProtocolErrorVectorOptionalResult struct { |
| I_protocolErrorVectorOptionalResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response VectorOptional `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mProtocolErrorVectorOptionalResult = _bindings.CreateLazyMarshaler(ProtocolErrorVectorOptionalResult{}) |
| |
| func (msg *ProtocolErrorVectorOptionalResult) Marshaler() _bindings.Marshaler { |
| return _mProtocolErrorVectorOptionalResult |
| } |
| |
| func (_m *ProtocolErrorVectorOptionalResult) reset() { |
| switch _m.I_protocolErrorVectorOptionalResultTag { |
| case 1: |
| var _zeroed VectorOptional |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *ProtocolErrorVectorOptionalResult) Which() I_protocolErrorVectorOptionalResultTag { |
| return _m.I_protocolErrorVectorOptionalResultTag |
| } |
| |
| func (_m *ProtocolErrorVectorOptionalResult) Ordinal() uint64 { |
| return uint64(_m.I_protocolErrorVectorOptionalResultTag) |
| } |
| |
| func (_m *ProtocolErrorVectorOptionalResult) SetResponse(response VectorOptional) { |
| _m.reset() |
| _m.I_protocolErrorVectorOptionalResultTag = ProtocolErrorVectorOptionalResultResponse |
| _m.Response = response |
| } |
| |
| func ProtocolErrorVectorOptionalResultWithResponse(response VectorOptional) ProtocolErrorVectorOptionalResult { |
| var _u ProtocolErrorVectorOptionalResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *ProtocolErrorVectorOptionalResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_protocolErrorVectorOptionalResultTag = ProtocolErrorVectorOptionalResultErr |
| _m.Err = err |
| } |
| |
| func ProtocolErrorVectorOptionalResultWithErr(err uint32) ProtocolErrorVectorOptionalResult { |
| var _u ProtocolErrorVectorOptionalResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_resourceUnionTag uint64 |
| |
| const ( |
| ResourceUnion_unknownData = 0 // 0x00000000 |
| ResourceUnionB = 1 // 0x00000001 |
| ) |
| |
| type ResourceUnion struct { |
| I_resourceUnionTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| I_unknownData interface{} |
| B bool `fidl_ordinal:"1"` |
| } |
| |
| var _mResourceUnion = _bindings.CreateLazyMarshaler(ResourceUnion{}) |
| |
| func (msg *ResourceUnion) Marshaler() _bindings.Marshaler { |
| return _mResourceUnion |
| } |
| |
| func (_m *ResourceUnion) reset() { |
| switch _m.I_resourceUnionTag { |
| case 1: |
| var _zeroed bool |
| _m.B = _zeroed |
| default: |
| var _zeroed interface{} |
| _m.I_unknownData = _zeroed |
| } |
| } |
| |
| func (_m *ResourceUnion) Which() I_resourceUnionTag { |
| switch _m.I_resourceUnionTag { |
| case 1: |
| return ResourceUnionB |
| default: |
| return ResourceUnion_unknownData |
| } |
| } |
| |
| func (_m *ResourceUnion) Ordinal() uint64 { |
| return uint64(_m.I_resourceUnionTag) |
| } |
| |
| func (_m *ResourceUnion) SetB(b bool) { |
| _m.reset() |
| _m.I_resourceUnionTag = ResourceUnionB |
| _m.B = b |
| } |
| |
| func ResourceUnionWithB(b bool) ResourceUnion { |
| var _u ResourceUnion |
| _u.SetB(b) |
| return _u |
| } |
| func (_m *ResourceUnion) GetUnknownData() _bindings.UnknownData { |
| return _m.I_unknownData.(_bindings.UnknownData) |
| } |
| |
| type I_unionTag uint64 |
| |
| const ( |
| Union_unknownData = 0 // 0x00000000 |
| UnionB = 1 // 0x00000001 |
| ) |
| |
| type Union struct { |
| I_unionTag `fidl:"x" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| B bool `fidl_ordinal:"1"` |
| } |
| |
| var _mUnion = _bindings.CreateLazyMarshaler(Union{}) |
| |
| func (msg *Union) Marshaler() _bindings.Marshaler { |
| return _mUnion |
| } |
| |
| func (_m *Union) reset() { |
| switch _m.I_unionTag { |
| case 1: |
| var _zeroed bool |
| _m.B = _zeroed |
| default: |
| var _zeroed interface{} |
| _m.I_unknownData = _zeroed |
| } |
| } |
| |
| func (_m *Union) Which() I_unionTag { |
| switch _m.I_unionTag { |
| case 1: |
| return UnionB |
| default: |
| return Union_unknownData |
| } |
| } |
| |
| func (_m *Union) Ordinal() uint64 { |
| return uint64(_m.I_unionTag) |
| } |
| |
| func (_m *Union) SetB(b bool) { |
| _m.reset() |
| _m.I_unionTag = UnionB |
| _m.B = b |
| } |
| |
| func UnionWithB(b bool) Union { |
| var _u Union |
| _u.SetB(b) |
| return _u |
| } |
| func (_m *Union) GetUnknownData() _bindings.UnknownData { |
| return _m.I_unknownData.(_bindings.UnknownData) |
| } |
| |
| type ResourceTable struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"` |
| I_unknownData interface{} |
| } |
| |
| var _mResourceTable = _bindings.CreateLazyMarshaler(ResourceTable{}) |
| |
| func (msg *ResourceTable) Marshaler() _bindings.Marshaler { |
| return _mResourceTable |
| } |
| |
| func (u *ResourceTable) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *ResourceTable) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| type Table struct { |
| _ struct{} `fidl:"t" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| } |
| |
| var _mTable = _bindings.CreateLazyMarshaler(Table{}) |
| |
| func (msg *Table) Marshaler() _bindings.Marshaler { |
| return _mTable |
| } |
| |
| func (u *Table) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *Table) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| const ( |
| ProtocolOneWayBasicOrdinal uint64 = 0x7c311f0d9e662df9 |
| ProtocolTwoWayBasicOrdinal uint64 = 0x205b92db5139c88f |
| ProtocolErrorBasicOrdinal uint64 = 0x459eaa5d11b9ff93 |
| ProtocolEventBasicOrdinal uint64 = 0x51c5b06295c10c40 |
| ProtocolOneWayCompoundOrdinal uint64 = 0x2bc2bc3a9237c6cc |
| ProtocolTwoWayCompoundOrdinal uint64 = 0x79f279c7201da131 |
| ProtocolErrorCompoundOrdinal uint64 = 0x29817d89a19ec77d |
| ProtocolEventCompoundOrdinal uint64 = 0x617c5410858734d5 |
| ProtocolOneWayArrayBasicOrdinal uint64 = 0x62e2ebcadf35ca19 |
| ProtocolTwoWayArrayBasicOrdinal uint64 = 0x49ad7a74e28ba114 |
| ProtocolErrorArrayBasicOrdinal uint64 = 0xf0dbde9626fff79 |
| ProtocolEventArrayBasicOrdinal uint64 = 0x51b76208b148f02e |
| ProtocolOneWayArrayCompoundOrdinal uint64 = 0x464948bae1bda09d |
| ProtocolTwoWayArrayCompoundOrdinal uint64 = 0xbcae616f8e1ea7b |
| ProtocolErrorArrayCompoundOrdinal uint64 = 0x52257f80e29c1a04 |
| ProtocolEventArrayCompoundOrdinal uint64 = 0x1e63a00079aa7415 |
| ProtocolOneWayVectorBasicOrdinal uint64 = 0x4f907dde77464657 |
| ProtocolTwoWayVectorBasicOrdinal uint64 = 0x7860cb3ed8362e74 |
| ProtocolErrorVectorBasicOrdinal uint64 = 0xc27f841d6313f72 |
| ProtocolEventVectorBasicOrdinal uint64 = 0x3f9d405e7191eff6 |
| ProtocolOneWayVectorCompoundOrdinal uint64 = 0x19baae42829dbe90 |
| ProtocolTwoWayVectorCompoundOrdinal uint64 = 0x371140db701b23b4 |
| ProtocolErrorVectorCompoundOrdinal uint64 = 0x760e278628f7a985 |
| ProtocolEventVectorCompoundOrdinal uint64 = 0x53a1fc56e8b3cff3 |
| ProtocolOneWayVectorOptionalOrdinal uint64 = 0x153c6b333c21c52f |
| ProtocolTwoWayVectorOptionalOrdinal uint64 = 0xe4b620aaafd73f3 |
| ProtocolErrorVectorOptionalOrdinal uint64 = 0x58e75cf86e2d715e |
| ProtocolEventVectorOptionalOrdinal uint64 = 0x17617b54dfa8d85d |
| ProtocolOneWayArrayVectorNestedOrdinal uint64 = 0x520dc9cb9b9b5ed7 |
| ProtocolTwoWayArrayVectorNestedOrdinal uint64 = 0x4a438ce0948817dc |
| ProtocolErrorArrayVectorNestedOrdinal uint64 = 0x7e168d89e1dac8a7 |
| ProtocolEventArrayVectorNestedOrdinal uint64 = 0x110b72cfebc4037e |
| ProtocolOneWayResourceOrdinal uint64 = 0x5af4795a9ed3a022 |
| ProtocolTwoWayResourceOrdinal uint64 = 0x1904824a11c6ad5b |
| ProtocolErrorResourceOrdinal uint64 = 0x5b28634d603175b6 |
| ProtocolEventResourceOrdinal uint64 = 0x4fbde2864601698b |
| ) |
| |
| type ProtocolWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *ProtocolWithCtxInterface) OneWayBasic(ctx_ _bindings.Context, uint8_ uint8, uint16_ uint16, uint32_ uint32, uint64_ uint64, int8_ int8, int16_ int16, int32_ int32, int64_ int64, float32 float32, float64 float64, string_ string, optString *string) error { |
| req_ := &Basic{Uint8: uint8_, Uint16: uint16_, Uint32: uint32_, Uint64: uint64_, Int8: int8_, Int16: int16_, Int32: int32_, Int64: int64_, Float32: float32, Float64: float64, String: string_, OptString: optString} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayBasicOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayBasic(ctx_ _bindings.Context, uint8_ uint8, uint16_ uint16, uint32_ uint32, uint64_ uint64, int8_ int8, int16_ int16, int32_ int32, int64_ int64, float32 float32, float64 float64, string_ string, optString *string) (uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, string, *string, error) { |
| req_ := &Basic{Uint8: uint8_, Uint16: uint16_, Uint32: uint32_, Uint64: uint64_, Int8: int8_, Int16: int16_, Int32: int32_, Int64: int64_, Float32: float32, Float64: float64, String: string_, OptString: optString} |
| resp_ := &Basic{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayBasicOrdinal, req_, resp_) |
| return (*resp_).Uint8, (*resp_).Uint16, (*resp_).Uint32, (*resp_).Uint64, (*resp_).Int8, (*resp_).Int16, (*resp_).Int32, (*resp_).Int64, (*resp_).Float32, (*resp_).Float64, (*resp_).String, (*resp_).OptString, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorBasic(ctx_ _bindings.Context) (ProtocolErrorBasicResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorBasicResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorBasicOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventBasic(ctx_ _bindings.Context) (uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, string, *string, error) { |
| resp_ := &Basic{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventBasicOrdinal, resp_) |
| return (*resp_).Uint8, (*resp_).Uint16, (*resp_).Uint32, (*resp_).Uint64, (*resp_).Int8, (*resp_).Int16, (*resp_).Int32, (*resp_).Int64, (*resp_).Float32, (*resp_).Float64, (*resp_).String, (*resp_).OptString, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayCompound(ctx_ _bindings.Context, bits Bits, enum Enum, struct_ Struct, table Table, union Union, optStruct *Struct, optUnion *Union) error { |
| req_ := &Compound{Bits: bits, Enum: enum, Struct: struct_, Table: table, Union: union, OptStruct: optStruct, OptUnion: optUnion} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayCompoundOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayCompound(ctx_ _bindings.Context, bits Bits, enum Enum, struct_ Struct, table Table, union Union, optStruct *Struct, optUnion *Union) (Bits, Enum, Struct, Table, Union, *Struct, *Union, error) { |
| req_ := &Compound{Bits: bits, Enum: enum, Struct: struct_, Table: table, Union: union, OptStruct: optStruct, OptUnion: optUnion} |
| resp_ := &Compound{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayCompoundOrdinal, req_, resp_) |
| return (*resp_).Bits, (*resp_).Enum, (*resp_).Struct, (*resp_).Table, (*resp_).Union, (*resp_).OptStruct, (*resp_).OptUnion, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorCompound(ctx_ _bindings.Context) (ProtocolErrorCompoundResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorCompoundResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorCompoundOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventCompound(ctx_ _bindings.Context) (Bits, Enum, Struct, Table, Union, *Struct, *Union, error) { |
| resp_ := &Compound{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventCompoundOrdinal, resp_) |
| return (*resp_).Bits, (*resp_).Enum, (*resp_).Struct, (*resp_).Table, (*resp_).Union, (*resp_).OptStruct, (*resp_).OptUnion, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayArrayBasic(ctx_ _bindings.Context, arrayUint8 [5]uint8, arrayUint16 [5]uint16, arrayUint32 [5]uint32, arrayUint64 [5]uint64, arrayInt8 [5]int8, arrayInt16 [5]int16, arrayInt32 [5]int32, arrayInt64 [5]int64, arrayFloat32 [5]float32, arrayFloat64 [5]float64, arrayString [5]string, arrayOptString [5]*string) error { |
| req_ := &ArrayBasic{ArrayUint8: arrayUint8, ArrayUint16: arrayUint16, ArrayUint32: arrayUint32, ArrayUint64: arrayUint64, ArrayInt8: arrayInt8, ArrayInt16: arrayInt16, ArrayInt32: arrayInt32, ArrayInt64: arrayInt64, ArrayFloat32: arrayFloat32, ArrayFloat64: arrayFloat64, ArrayString: arrayString, ArrayOptString: arrayOptString} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayArrayBasicOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayArrayBasic(ctx_ _bindings.Context, arrayUint8 [5]uint8, arrayUint16 [5]uint16, arrayUint32 [5]uint32, arrayUint64 [5]uint64, arrayInt8 [5]int8, arrayInt16 [5]int16, arrayInt32 [5]int32, arrayInt64 [5]int64, arrayFloat32 [5]float32, arrayFloat64 [5]float64, arrayString [5]string, arrayOptString [5]*string) ([5]uint8, [5]uint16, [5]uint32, [5]uint64, [5]int8, [5]int16, [5]int32, [5]int64, [5]float32, [5]float64, [5]string, [5]*string, error) { |
| req_ := &ArrayBasic{ArrayUint8: arrayUint8, ArrayUint16: arrayUint16, ArrayUint32: arrayUint32, ArrayUint64: arrayUint64, ArrayInt8: arrayInt8, ArrayInt16: arrayInt16, ArrayInt32: arrayInt32, ArrayInt64: arrayInt64, ArrayFloat32: arrayFloat32, ArrayFloat64: arrayFloat64, ArrayString: arrayString, ArrayOptString: arrayOptString} |
| resp_ := &ArrayBasic{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayArrayBasicOrdinal, req_, resp_) |
| return (*resp_).ArrayUint8, (*resp_).ArrayUint16, (*resp_).ArrayUint32, (*resp_).ArrayUint64, (*resp_).ArrayInt8, (*resp_).ArrayInt16, (*resp_).ArrayInt32, (*resp_).ArrayInt64, (*resp_).ArrayFloat32, (*resp_).ArrayFloat64, (*resp_).ArrayString, (*resp_).ArrayOptString, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorArrayBasic(ctx_ _bindings.Context) (ProtocolErrorArrayBasicResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorArrayBasicResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorArrayBasicOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventArrayBasic(ctx_ _bindings.Context) ([5]uint8, [5]uint16, [5]uint32, [5]uint64, [5]int8, [5]int16, [5]int32, [5]int64, [5]float32, [5]float64, [5]string, [5]*string, error) { |
| resp_ := &ArrayBasic{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventArrayBasicOrdinal, resp_) |
| return (*resp_).ArrayUint8, (*resp_).ArrayUint16, (*resp_).ArrayUint32, (*resp_).ArrayUint64, (*resp_).ArrayInt8, (*resp_).ArrayInt16, (*resp_).ArrayInt32, (*resp_).ArrayInt64, (*resp_).ArrayFloat32, (*resp_).ArrayFloat64, (*resp_).ArrayString, (*resp_).ArrayOptString, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayArrayCompound(ctx_ _bindings.Context, arrayBits [5]Bits, arrayEnum [5]Enum, arrayStruct [5]Struct, arrayTable [5]Table, arrayUnion [5]Union, arrayOptStruct [5]*Struct, arrayOptUnion [5]*Union) error { |
| req_ := &ArrayCompound{ArrayBits: arrayBits, ArrayEnum: arrayEnum, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, ArrayOptStruct: arrayOptStruct, ArrayOptUnion: arrayOptUnion} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayArrayCompoundOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayArrayCompound(ctx_ _bindings.Context, arrayBits [5]Bits, arrayEnum [5]Enum, arrayStruct [5]Struct, arrayTable [5]Table, arrayUnion [5]Union, arrayOptStruct [5]*Struct, arrayOptUnion [5]*Union) ([5]Bits, [5]Enum, [5]Struct, [5]Table, [5]Union, [5]*Struct, [5]*Union, error) { |
| req_ := &ArrayCompound{ArrayBits: arrayBits, ArrayEnum: arrayEnum, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, ArrayOptStruct: arrayOptStruct, ArrayOptUnion: arrayOptUnion} |
| resp_ := &ArrayCompound{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayArrayCompoundOrdinal, req_, resp_) |
| return (*resp_).ArrayBits, (*resp_).ArrayEnum, (*resp_).ArrayStruct, (*resp_).ArrayTable, (*resp_).ArrayUnion, (*resp_).ArrayOptStruct, (*resp_).ArrayOptUnion, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorArrayCompound(ctx_ _bindings.Context) (ProtocolErrorArrayCompoundResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorArrayCompoundResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorArrayCompoundOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventArrayCompound(ctx_ _bindings.Context) ([5]Bits, [5]Enum, [5]Struct, [5]Table, [5]Union, [5]*Struct, [5]*Union, error) { |
| resp_ := &ArrayCompound{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventArrayCompoundOrdinal, resp_) |
| return (*resp_).ArrayBits, (*resp_).ArrayEnum, (*resp_).ArrayStruct, (*resp_).ArrayTable, (*resp_).ArrayUnion, (*resp_).ArrayOptStruct, (*resp_).ArrayOptUnion, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayVectorBasic(ctx_ _bindings.Context, vectorUint8 []uint8, vectorUint16 []uint16, vectorUint32 []uint32, vectorUint64 []uint64, vectorInt8 []int8, vectorInt16 []int16, vectorInt32 []int32, vectorInt64 []int64, vectorFloat32 []float32, vectorFloat64 []float64, vectorString []string, vectorOptString []*string) error { |
| req_ := &VectorBasic{VectorUint8: vectorUint8, VectorUint16: vectorUint16, VectorUint32: vectorUint32, VectorUint64: vectorUint64, VectorInt8: vectorInt8, VectorInt16: vectorInt16, VectorInt32: vectorInt32, VectorInt64: vectorInt64, VectorFloat32: vectorFloat32, VectorFloat64: vectorFloat64, VectorString: vectorString, VectorOptString: vectorOptString} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayVectorBasicOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayVectorBasic(ctx_ _bindings.Context, vectorUint8 []uint8, vectorUint16 []uint16, vectorUint32 []uint32, vectorUint64 []uint64, vectorInt8 []int8, vectorInt16 []int16, vectorInt32 []int32, vectorInt64 []int64, vectorFloat32 []float32, vectorFloat64 []float64, vectorString []string, vectorOptString []*string) ([]uint8, []uint16, []uint32, []uint64, []int8, []int16, []int32, []int64, []float32, []float64, []string, []*string, error) { |
| req_ := &VectorBasic{VectorUint8: vectorUint8, VectorUint16: vectorUint16, VectorUint32: vectorUint32, VectorUint64: vectorUint64, VectorInt8: vectorInt8, VectorInt16: vectorInt16, VectorInt32: vectorInt32, VectorInt64: vectorInt64, VectorFloat32: vectorFloat32, VectorFloat64: vectorFloat64, VectorString: vectorString, VectorOptString: vectorOptString} |
| resp_ := &VectorBasic{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayVectorBasicOrdinal, req_, resp_) |
| return (*resp_).VectorUint8, (*resp_).VectorUint16, (*resp_).VectorUint32, (*resp_).VectorUint64, (*resp_).VectorInt8, (*resp_).VectorInt16, (*resp_).VectorInt32, (*resp_).VectorInt64, (*resp_).VectorFloat32, (*resp_).VectorFloat64, (*resp_).VectorString, (*resp_).VectorOptString, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorVectorBasic(ctx_ _bindings.Context) (ProtocolErrorVectorBasicResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorVectorBasicResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorVectorBasicOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventVectorBasic(ctx_ _bindings.Context) ([]uint8, []uint16, []uint32, []uint64, []int8, []int16, []int32, []int64, []float32, []float64, []string, []*string, error) { |
| resp_ := &VectorBasic{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventVectorBasicOrdinal, resp_) |
| return (*resp_).VectorUint8, (*resp_).VectorUint16, (*resp_).VectorUint32, (*resp_).VectorUint64, (*resp_).VectorInt8, (*resp_).VectorInt16, (*resp_).VectorInt32, (*resp_).VectorInt64, (*resp_).VectorFloat32, (*resp_).VectorFloat64, (*resp_).VectorString, (*resp_).VectorOptString, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayVectorCompound(ctx_ _bindings.Context, vectorBits []Bits, vectorEnum []Enum, vectorStruct []Struct, vectorTable []Table, vectorUnion []Union, vectorOptStruct []*Struct, vectorOptUnion []*Union) error { |
| req_ := &VectorCompound{VectorBits: vectorBits, VectorEnum: vectorEnum, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion, VectorOptStruct: vectorOptStruct, VectorOptUnion: vectorOptUnion} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayVectorCompoundOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayVectorCompound(ctx_ _bindings.Context, vectorBits []Bits, vectorEnum []Enum, vectorStruct []Struct, vectorTable []Table, vectorUnion []Union, vectorOptStruct []*Struct, vectorOptUnion []*Union) ([]Bits, []Enum, []Struct, []Table, []Union, []*Struct, []*Union, error) { |
| req_ := &VectorCompound{VectorBits: vectorBits, VectorEnum: vectorEnum, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion, VectorOptStruct: vectorOptStruct, VectorOptUnion: vectorOptUnion} |
| resp_ := &VectorCompound{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayVectorCompoundOrdinal, req_, resp_) |
| return (*resp_).VectorBits, (*resp_).VectorEnum, (*resp_).VectorStruct, (*resp_).VectorTable, (*resp_).VectorUnion, (*resp_).VectorOptStruct, (*resp_).VectorOptUnion, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorVectorCompound(ctx_ _bindings.Context) (ProtocolErrorVectorCompoundResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorVectorCompoundResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorVectorCompoundOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventVectorCompound(ctx_ _bindings.Context) ([]Bits, []Enum, []Struct, []Table, []Union, []*Struct, []*Union, error) { |
| resp_ := &VectorCompound{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventVectorCompoundOrdinal, resp_) |
| return (*resp_).VectorBits, (*resp_).VectorEnum, (*resp_).VectorStruct, (*resp_).VectorTable, (*resp_).VectorUnion, (*resp_).VectorOptStruct, (*resp_).VectorOptUnion, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayVectorOptional(ctx_ _bindings.Context, optVectorUint8 *[]uint8, optVectorString *[]string, optVectorStruct *[]Struct, optVectorOptStruct *[]*Struct) error { |
| req_ := &VectorOptional{OptVectorUint8: optVectorUint8, OptVectorString: optVectorString, OptVectorStruct: optVectorStruct, OptVectorOptStruct: optVectorOptStruct} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayVectorOptionalOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayVectorOptional(ctx_ _bindings.Context, optVectorUint8 *[]uint8, optVectorString *[]string, optVectorStruct *[]Struct, optVectorOptStruct *[]*Struct) (*[]uint8, *[]string, *[]Struct, *[]*Struct, error) { |
| req_ := &VectorOptional{OptVectorUint8: optVectorUint8, OptVectorString: optVectorString, OptVectorStruct: optVectorStruct, OptVectorOptStruct: optVectorOptStruct} |
| resp_ := &VectorOptional{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayVectorOptionalOrdinal, req_, resp_) |
| return (*resp_).OptVectorUint8, (*resp_).OptVectorString, (*resp_).OptVectorStruct, (*resp_).OptVectorOptStruct, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorVectorOptional(ctx_ _bindings.Context) (ProtocolErrorVectorOptionalResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorVectorOptionalResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorVectorOptionalOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventVectorOptional(ctx_ _bindings.Context) (*[]uint8, *[]string, *[]Struct, *[]*Struct, error) { |
| resp_ := &VectorOptional{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventVectorOptionalOrdinal, resp_) |
| return (*resp_).OptVectorUint8, (*resp_).OptVectorString, (*resp_).OptVectorStruct, (*resp_).OptVectorOptStruct, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayArrayVectorNested(ctx_ _bindings.Context, arrayArrayUint8 [5][5]uint8, arrayVectorUint8 [5][]uint8, vectorArrayUint8 [][5]uint8, vectorVectorUint8 [][]uint8) error { |
| req_ := &ArrayVectorNested{ArrayArrayUint8: arrayArrayUint8, ArrayVectorUint8: arrayVectorUint8, VectorArrayUint8: vectorArrayUint8, VectorVectorUint8: vectorVectorUint8} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayArrayVectorNestedOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayArrayVectorNested(ctx_ _bindings.Context, arrayArrayUint8 [5][5]uint8, arrayVectorUint8 [5][]uint8, vectorArrayUint8 [][5]uint8, vectorVectorUint8 [][]uint8) ([5][5]uint8, [5][]uint8, [][5]uint8, [][]uint8, error) { |
| req_ := &ArrayVectorNested{ArrayArrayUint8: arrayArrayUint8, ArrayVectorUint8: arrayVectorUint8, VectorArrayUint8: vectorArrayUint8, VectorVectorUint8: vectorVectorUint8} |
| resp_ := &ArrayVectorNested{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayArrayVectorNestedOrdinal, req_, resp_) |
| return (*resp_).ArrayArrayUint8, (*resp_).ArrayVectorUint8, (*resp_).VectorArrayUint8, (*resp_).VectorVectorUint8, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorArrayVectorNested(ctx_ _bindings.Context) (ProtocolErrorArrayVectorNestedResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorArrayVectorNestedResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorArrayVectorNestedOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventArrayVectorNested(ctx_ _bindings.Context) ([5][5]uint8, [5][]uint8, [][5]uint8, [][]uint8, error) { |
| resp_ := &ArrayVectorNested{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventArrayVectorNestedOrdinal, resp_) |
| return (*resp_).ArrayArrayUint8, (*resp_).ArrayVectorUint8, (*resp_).VectorArrayUint8, (*resp_).VectorVectorUint8, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) OneWayResource(ctx_ _bindings.Context, handle _zx.Handle, vmo _zx.VMO, clientEnd ProtocolWithCtxInterface, serverEnd ProtocolWithCtxInterfaceRequest, struct_ ResourceStruct, table ResourceTable, union ResourceUnion, optHandle _zx.Handle, optVmo _zx.VMO, optClientEnd ProtocolWithCtxInterface, optServerEnd ProtocolWithCtxInterfaceRequest, optStruct *ResourceStruct, optUnion *ResourceUnion, arrayHandle [5]_zx.Handle, arrayVmo [5]_zx.VMO, arrayClientEnd [5]ProtocolWithCtxInterface, arrayServerEnd [5]ProtocolWithCtxInterfaceRequest, arrayStruct [5]ResourceStruct, arrayTable [5]ResourceTable, arrayUnion [5]ResourceUnion, vectorHandle []_zx.Handle, vectorVmo []_zx.VMO, vectorClientEnd []ProtocolWithCtxInterface, vectorServerEnd []ProtocolWithCtxInterfaceRequest, vectorStruct []ResourceStruct, vectorTable []ResourceTable, vectorUnion []ResourceUnion) error { |
| req_ := &Resource{Handle: handle, Vmo: vmo, ClientEnd: clientEnd, ServerEnd: serverEnd, Struct: struct_, Table: table, Union: union, OptHandle: optHandle, OptVmo: optVmo, OptClientEnd: optClientEnd, OptServerEnd: optServerEnd, OptStruct: optStruct, OptUnion: optUnion, ArrayHandle: arrayHandle, ArrayVmo: arrayVmo, ArrayClientEnd: arrayClientEnd, ArrayServerEnd: arrayServerEnd, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, VectorHandle: vectorHandle, VectorVmo: vectorVmo, VectorClientEnd: vectorClientEnd, VectorServerEnd: vectorServerEnd, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(ProtocolOneWayResourceOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) TwoWayResource(ctx_ _bindings.Context, handle _zx.Handle, vmo _zx.VMO, clientEnd ProtocolWithCtxInterface, serverEnd ProtocolWithCtxInterfaceRequest, struct_ ResourceStruct, table ResourceTable, union ResourceUnion, optHandle _zx.Handle, optVmo _zx.VMO, optClientEnd ProtocolWithCtxInterface, optServerEnd ProtocolWithCtxInterfaceRequest, optStruct *ResourceStruct, optUnion *ResourceUnion, arrayHandle [5]_zx.Handle, arrayVmo [5]_zx.VMO, arrayClientEnd [5]ProtocolWithCtxInterface, arrayServerEnd [5]ProtocolWithCtxInterfaceRequest, arrayStruct [5]ResourceStruct, arrayTable [5]ResourceTable, arrayUnion [5]ResourceUnion, vectorHandle []_zx.Handle, vectorVmo []_zx.VMO, vectorClientEnd []ProtocolWithCtxInterface, vectorServerEnd []ProtocolWithCtxInterfaceRequest, vectorStruct []ResourceStruct, vectorTable []ResourceTable, vectorUnion []ResourceUnion) (_zx.Handle, _zx.VMO, ProtocolWithCtxInterface, ProtocolWithCtxInterfaceRequest, ResourceStruct, ResourceTable, ResourceUnion, _zx.Handle, _zx.VMO, ProtocolWithCtxInterface, ProtocolWithCtxInterfaceRequest, *ResourceStruct, *ResourceUnion, [5]_zx.Handle, [5]_zx.VMO, [5]ProtocolWithCtxInterface, [5]ProtocolWithCtxInterfaceRequest, [5]ResourceStruct, [5]ResourceTable, [5]ResourceUnion, []_zx.Handle, []_zx.VMO, []ProtocolWithCtxInterface, []ProtocolWithCtxInterfaceRequest, []ResourceStruct, []ResourceTable, []ResourceUnion, error) { |
| req_ := &Resource{Handle: handle, Vmo: vmo, ClientEnd: clientEnd, ServerEnd: serverEnd, Struct: struct_, Table: table, Union: union, OptHandle: optHandle, OptVmo: optVmo, OptClientEnd: optClientEnd, OptServerEnd: optServerEnd, OptStruct: optStruct, OptUnion: optUnion, ArrayHandle: arrayHandle, ArrayVmo: arrayVmo, ArrayClientEnd: arrayClientEnd, ArrayServerEnd: arrayServerEnd, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, VectorHandle: vectorHandle, VectorVmo: vectorVmo, VectorClientEnd: vectorClientEnd, VectorServerEnd: vectorServerEnd, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion} |
| resp_ := &Resource{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolTwoWayResourceOrdinal, req_, resp_) |
| return (*resp_).Handle, (*resp_).Vmo, (*resp_).ClientEnd, (*resp_).ServerEnd, (*resp_).Struct, (*resp_).Table, (*resp_).Union, (*resp_).OptHandle, (*resp_).OptVmo, (*resp_).OptClientEnd, (*resp_).OptServerEnd, (*resp_).OptStruct, (*resp_).OptUnion, (*resp_).ArrayHandle, (*resp_).ArrayVmo, (*resp_).ArrayClientEnd, (*resp_).ArrayServerEnd, (*resp_).ArrayStruct, (*resp_).ArrayTable, (*resp_).ArrayUnion, (*resp_).VectorHandle, (*resp_).VectorVmo, (*resp_).VectorClientEnd, (*resp_).VectorServerEnd, (*resp_).VectorStruct, (*resp_).VectorTable, (*resp_).VectorUnion, err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ErrorResource(ctx_ _bindings.Context) (ProtocolErrorResourceResult, error) { |
| var req_ _bindings.Message |
| resp_ := &ProtocolErrorResourceResult{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(ProtocolErrorResourceOrdinal, req_, resp_) |
| return (*resp_), err_ |
| } |
| |
| func (p *ProtocolWithCtxInterface) ExpectEventResource(ctx_ _bindings.Context) (_zx.Handle, _zx.VMO, ProtocolWithCtxInterface, ProtocolWithCtxInterfaceRequest, ResourceStruct, ResourceTable, ResourceUnion, _zx.Handle, _zx.VMO, ProtocolWithCtxInterface, ProtocolWithCtxInterfaceRequest, *ResourceStruct, *ResourceUnion, [5]_zx.Handle, [5]_zx.VMO, [5]ProtocolWithCtxInterface, [5]ProtocolWithCtxInterfaceRequest, [5]ResourceStruct, [5]ResourceTable, [5]ResourceUnion, []_zx.Handle, []_zx.VMO, []ProtocolWithCtxInterface, []ProtocolWithCtxInterfaceRequest, []ResourceStruct, []ResourceTable, []ResourceUnion, error) { |
| resp_ := &Resource{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(ProtocolEventResourceOrdinal, resp_) |
| return (*resp_).Handle, (*resp_).Vmo, (*resp_).ClientEnd, (*resp_).ServerEnd, (*resp_).Struct, (*resp_).Table, (*resp_).Union, (*resp_).OptHandle, (*resp_).OptVmo, (*resp_).OptClientEnd, (*resp_).OptServerEnd, (*resp_).OptStruct, (*resp_).OptUnion, (*resp_).ArrayHandle, (*resp_).ArrayVmo, (*resp_).ArrayClientEnd, (*resp_).ArrayServerEnd, (*resp_).ArrayStruct, (*resp_).ArrayTable, (*resp_).ArrayUnion, (*resp_).VectorHandle, (*resp_).VectorVmo, (*resp_).VectorClientEnd, (*resp_).VectorServerEnd, (*resp_).VectorStruct, (*resp_).VectorTable, (*resp_).VectorUnion, err_ |
| } |
| |
| type ProtocolWithCtx interface { |
| OneWayBasic(ctx_ _bindings.Context, uint8_ uint8, uint16_ uint16, uint32_ uint32, uint64_ uint64, int8_ int8, int16_ int16, int32_ int32, int64_ int64, float32 float32, float64 float64, string_ string, optString *string) error |
| TwoWayBasic(ctx_ _bindings.Context, uint8_ uint8, uint16_ uint16, uint32_ uint32, uint64_ uint64, int8_ int8, int16_ int16, int32_ int32, int64_ int64, float32 float32, float64 float64, string_ string, optString *string) (uint8, uint16, uint32, uint64, int8, int16, int32, int64, float32, float64, string, *string, error) |
| ErrorBasic(ctx_ _bindings.Context) (ProtocolErrorBasicResult, error) |
| OneWayCompound(ctx_ _bindings.Context, bits Bits, enum Enum, struct_ Struct, table Table, union Union, optStruct *Struct, optUnion *Union) error |
| TwoWayCompound(ctx_ _bindings.Context, bits Bits, enum Enum, struct_ Struct, table Table, union Union, optStruct *Struct, optUnion *Union) (Bits, Enum, Struct, Table, Union, *Struct, *Union, error) |
| ErrorCompound(ctx_ _bindings.Context) (ProtocolErrorCompoundResult, error) |
| OneWayArrayBasic(ctx_ _bindings.Context, arrayUint8 [5]uint8, arrayUint16 [5]uint16, arrayUint32 [5]uint32, arrayUint64 [5]uint64, arrayInt8 [5]int8, arrayInt16 [5]int16, arrayInt32 [5]int32, arrayInt64 [5]int64, arrayFloat32 [5]float32, arrayFloat64 [5]float64, arrayString [5]string, arrayOptString [5]*string) error |
| TwoWayArrayBasic(ctx_ _bindings.Context, arrayUint8 [5]uint8, arrayUint16 [5]uint16, arrayUint32 [5]uint32, arrayUint64 [5]uint64, arrayInt8 [5]int8, arrayInt16 [5]int16, arrayInt32 [5]int32, arrayInt64 [5]int64, arrayFloat32 [5]float32, arrayFloat64 [5]float64, arrayString [5]string, arrayOptString [5]*string) ([5]uint8, [5]uint16, [5]uint32, [5]uint64, [5]int8, [5]int16, [5]int32, [5]int64, [5]float32, [5]float64, [5]string, [5]*string, error) |
| ErrorArrayBasic(ctx_ _bindings.Context) (ProtocolErrorArrayBasicResult, error) |
| OneWayArrayCompound(ctx_ _bindings.Context, arrayBits [5]Bits, arrayEnum [5]Enum, arrayStruct [5]Struct, arrayTable [5]Table, arrayUnion [5]Union, arrayOptStruct [5]*Struct, arrayOptUnion [5]*Union) error |
| TwoWayArrayCompound(ctx_ _bindings.Context, arrayBits [5]Bits, arrayEnum [5]Enum, arrayStruct [5]Struct, arrayTable [5]Table, arrayUnion [5]Union, arrayOptStruct [5]*Struct, arrayOptUnion [5]*Union) ([5]Bits, [5]Enum, [5]Struct, [5]Table, [5]Union, [5]*Struct, [5]*Union, error) |
| ErrorArrayCompound(ctx_ _bindings.Context) (ProtocolErrorArrayCompoundResult, error) |
| OneWayVectorBasic(ctx_ _bindings.Context, vectorUint8 []uint8, vectorUint16 []uint16, vectorUint32 []uint32, vectorUint64 []uint64, vectorInt8 []int8, vectorInt16 []int16, vectorInt32 []int32, vectorInt64 []int64, vectorFloat32 []float32, vectorFloat64 []float64, vectorString []string, vectorOptString []*string) error |
| TwoWayVectorBasic(ctx_ _bindings.Context, vectorUint8 []uint8, vectorUint16 []uint16, vectorUint32 []uint32, vectorUint64 []uint64, vectorInt8 []int8, vectorInt16 []int16, vectorInt32 []int32, vectorInt64 []int64, vectorFloat32 []float32, vectorFloat64 []float64, vectorString []string, vectorOptString []*string) ([]uint8, []uint16, []uint32, []uint64, []int8, []int16, []int32, []int64, []float32, []float64, []string, []*string, error) |
| ErrorVectorBasic(ctx_ _bindings.Context) (ProtocolErrorVectorBasicResult, error) |
| OneWayVectorCompound(ctx_ _bindings.Context, vectorBits []Bits, vectorEnum []Enum, vectorStruct []Struct, vectorTable []Table, vectorUnion []Union, vectorOptStruct []*Struct, vectorOptUnion []*Union) error |
| TwoWayVectorCompound(ctx_ _bindings.Context, vectorBits []Bits, vectorEnum []Enum, vectorStruct []Struct, vectorTable []Table, vectorUnion []Union, vectorOptStruct []*Struct, vectorOptUnion []*Union) ([]Bits, []Enum, []Struct, []Table, []Union, []*Struct, []*Union, error) |
| ErrorVectorCompound(ctx_ _bindings.Context) (ProtocolErrorVectorCompoundResult, error) |
| OneWayVectorOptional(ctx_ _bindings.Context, optVectorUint8 *[]uint8, optVectorString *[]string, optVectorStruct *[]Struct, optVectorOptStruct *[]*Struct) error |
| TwoWayVectorOptional(ctx_ _bindings.Context, optVectorUint8 *[]uint8, optVectorString *[]string, optVectorStruct *[]Struct, optVectorOptStruct *[]*Struct) (*[]uint8, *[]string, *[]Struct, *[]*Struct, error) |
| ErrorVectorOptional(ctx_ _bindings.Context) (ProtocolErrorVectorOptionalResult, error) |
| OneWayArrayVectorNested(ctx_ _bindings.Context, arrayArrayUint8 [5][5]uint8, arrayVectorUint8 [5][]uint8, vectorArrayUint8 [][5]uint8, vectorVectorUint8 [][]uint8) error |
| TwoWayArrayVectorNested(ctx_ _bindings.Context, arrayArrayUint8 [5][5]uint8, arrayVectorUint8 [5][]uint8, vectorArrayUint8 [][5]uint8, vectorVectorUint8 [][]uint8) ([5][5]uint8, [5][]uint8, [][5]uint8, [][]uint8, error) |
| ErrorArrayVectorNested(ctx_ _bindings.Context) (ProtocolErrorArrayVectorNestedResult, error) |
| OneWayResource(ctx_ _bindings.Context, handle _zx.Handle, vmo _zx.VMO, clientEnd ProtocolWithCtxInterface, serverEnd ProtocolWithCtxInterfaceRequest, struct_ ResourceStruct, table ResourceTable, union ResourceUnion, optHandle _zx.Handle, optVmo _zx.VMO, optClientEnd ProtocolWithCtxInterface, optServerEnd ProtocolWithCtxInterfaceRequest, optStruct *ResourceStruct, optUnion *ResourceUnion, arrayHandle [5]_zx.Handle, arrayVmo [5]_zx.VMO, arrayClientEnd [5]ProtocolWithCtxInterface, arrayServerEnd [5]ProtocolWithCtxInterfaceRequest, arrayStruct [5]ResourceStruct, arrayTable [5]ResourceTable, arrayUnion [5]ResourceUnion, vectorHandle []_zx.Handle, vectorVmo []_zx.VMO, vectorClientEnd []ProtocolWithCtxInterface, vectorServerEnd []ProtocolWithCtxInterfaceRequest, vectorStruct []ResourceStruct, vectorTable []ResourceTable, vectorUnion []ResourceUnion) error |
| TwoWayResource(ctx_ _bindings.Context, handle _zx.Handle, vmo _zx.VMO, clientEnd ProtocolWithCtxInterface, serverEnd ProtocolWithCtxInterfaceRequest, struct_ ResourceStruct, table ResourceTable, union ResourceUnion, optHandle _zx.Handle, optVmo _zx.VMO, optClientEnd ProtocolWithCtxInterface, optServerEnd ProtocolWithCtxInterfaceRequest, optStruct *ResourceStruct, optUnion *ResourceUnion, arrayHandle [5]_zx.Handle, arrayVmo [5]_zx.VMO, arrayClientEnd [5]ProtocolWithCtxInterface, arrayServerEnd [5]ProtocolWithCtxInterfaceRequest, arrayStruct [5]ResourceStruct, arrayTable [5]ResourceTable, arrayUnion [5]ResourceUnion, vectorHandle []_zx.Handle, vectorVmo []_zx.VMO, vectorClientEnd []ProtocolWithCtxInterface, vectorServerEnd []ProtocolWithCtxInterfaceRequest, vectorStruct []ResourceStruct, vectorTable []ResourceTable, vectorUnion []ResourceUnion) (_zx.Handle, _zx.VMO, ProtocolWithCtxInterface, ProtocolWithCtxInterfaceRequest, ResourceStruct, ResourceTable, ResourceUnion, _zx.Handle, _zx.VMO, ProtocolWithCtxInterface, ProtocolWithCtxInterfaceRequest, *ResourceStruct, *ResourceUnion, [5]_zx.Handle, [5]_zx.VMO, [5]ProtocolWithCtxInterface, [5]ProtocolWithCtxInterfaceRequest, [5]ResourceStruct, [5]ResourceTable, [5]ResourceUnion, []_zx.Handle, []_zx.VMO, []ProtocolWithCtxInterface, []ProtocolWithCtxInterfaceRequest, []ResourceStruct, []ResourceTable, []ResourceUnion, error) |
| ErrorResource(ctx_ _bindings.Context) (ProtocolErrorResourceResult, error) |
| } |
| type ProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewProtocolWithCtxInterfaceRequest() (ProtocolWithCtxInterfaceRequest, *ProtocolWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return ProtocolWithCtxInterfaceRequest(req), (*ProtocolWithCtxInterface)(cli), err |
| } |
| |
| type ProtocolWithCtxStub struct { |
| Impl ProtocolWithCtx |
| } |
| |
| func (s_ *ProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case ProtocolOneWayBasicOrdinal: |
| in_ := &Basic{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayBasic(args_.Ctx, (*in_).Uint8, (*in_).Uint16, (*in_).Uint32, (*in_).Uint64, (*in_).Int8, (*in_).Int16, (*in_).Int32, (*in_).Int64, (*in_).Float32, (*in_).Float64, (*in_).String, (*in_).OptString) |
| return nil, false, err_ |
| case ProtocolTwoWayBasicOrdinal: |
| in_ := &Basic{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| uint8_, uint16_, uint32_, uint64_, int8_, int16_, int32_, int64_, float32, float64, string_, optString, err_ := s_.Impl.TwoWayBasic(args_.Ctx, (*in_).Uint8, (*in_).Uint16, (*in_).Uint32, (*in_).Uint64, (*in_).Int8, (*in_).Int16, (*in_).Int32, (*in_).Int64, (*in_).Float32, (*in_).Float64, (*in_).String, (*in_).OptString) |
| out_ := &Basic{Uint8: uint8_, Uint16: uint16_, Uint32: uint32_, Uint64: uint64_, Int8: int8_, Int16: int16_, Int32: int32_, Int64: int64_, Float32: float32, Float64: float64, String: string_, OptString: optString} |
| return out_, true, err_ |
| case ProtocolErrorBasicOrdinal: |
| payload, err_ := s_.Impl.ErrorBasic(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayCompoundOrdinal: |
| in_ := &Compound{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayCompound(args_.Ctx, (*in_).Bits, (*in_).Enum, (*in_).Struct, (*in_).Table, (*in_).Union, (*in_).OptStruct, (*in_).OptUnion) |
| return nil, false, err_ |
| case ProtocolTwoWayCompoundOrdinal: |
| in_ := &Compound{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| bits, enum, struct_, table, union, optStruct, optUnion, err_ := s_.Impl.TwoWayCompound(args_.Ctx, (*in_).Bits, (*in_).Enum, (*in_).Struct, (*in_).Table, (*in_).Union, (*in_).OptStruct, (*in_).OptUnion) |
| out_ := &Compound{Bits: bits, Enum: enum, Struct: struct_, Table: table, Union: union, OptStruct: optStruct, OptUnion: optUnion} |
| return out_, true, err_ |
| case ProtocolErrorCompoundOrdinal: |
| payload, err_ := s_.Impl.ErrorCompound(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayArrayBasicOrdinal: |
| in_ := &ArrayBasic{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayArrayBasic(args_.Ctx, (*in_).ArrayUint8, (*in_).ArrayUint16, (*in_).ArrayUint32, (*in_).ArrayUint64, (*in_).ArrayInt8, (*in_).ArrayInt16, (*in_).ArrayInt32, (*in_).ArrayInt64, (*in_).ArrayFloat32, (*in_).ArrayFloat64, (*in_).ArrayString, (*in_).ArrayOptString) |
| return nil, false, err_ |
| case ProtocolTwoWayArrayBasicOrdinal: |
| in_ := &ArrayBasic{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| arrayUint8, arrayUint16, arrayUint32, arrayUint64, arrayInt8, arrayInt16, arrayInt32, arrayInt64, arrayFloat32, arrayFloat64, arrayString, arrayOptString, err_ := s_.Impl.TwoWayArrayBasic(args_.Ctx, (*in_).ArrayUint8, (*in_).ArrayUint16, (*in_).ArrayUint32, (*in_).ArrayUint64, (*in_).ArrayInt8, (*in_).ArrayInt16, (*in_).ArrayInt32, (*in_).ArrayInt64, (*in_).ArrayFloat32, (*in_).ArrayFloat64, (*in_).ArrayString, (*in_).ArrayOptString) |
| out_ := &ArrayBasic{ArrayUint8: arrayUint8, ArrayUint16: arrayUint16, ArrayUint32: arrayUint32, ArrayUint64: arrayUint64, ArrayInt8: arrayInt8, ArrayInt16: arrayInt16, ArrayInt32: arrayInt32, ArrayInt64: arrayInt64, ArrayFloat32: arrayFloat32, ArrayFloat64: arrayFloat64, ArrayString: arrayString, ArrayOptString: arrayOptString} |
| return out_, true, err_ |
| case ProtocolErrorArrayBasicOrdinal: |
| payload, err_ := s_.Impl.ErrorArrayBasic(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayArrayCompoundOrdinal: |
| in_ := &ArrayCompound{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayArrayCompound(args_.Ctx, (*in_).ArrayBits, (*in_).ArrayEnum, (*in_).ArrayStruct, (*in_).ArrayTable, (*in_).ArrayUnion, (*in_).ArrayOptStruct, (*in_).ArrayOptUnion) |
| return nil, false, err_ |
| case ProtocolTwoWayArrayCompoundOrdinal: |
| in_ := &ArrayCompound{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| arrayBits, arrayEnum, arrayStruct, arrayTable, arrayUnion, arrayOptStruct, arrayOptUnion, err_ := s_.Impl.TwoWayArrayCompound(args_.Ctx, (*in_).ArrayBits, (*in_).ArrayEnum, (*in_).ArrayStruct, (*in_).ArrayTable, (*in_).ArrayUnion, (*in_).ArrayOptStruct, (*in_).ArrayOptUnion) |
| out_ := &ArrayCompound{ArrayBits: arrayBits, ArrayEnum: arrayEnum, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, ArrayOptStruct: arrayOptStruct, ArrayOptUnion: arrayOptUnion} |
| return out_, true, err_ |
| case ProtocolErrorArrayCompoundOrdinal: |
| payload, err_ := s_.Impl.ErrorArrayCompound(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayVectorBasicOrdinal: |
| in_ := &VectorBasic{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayVectorBasic(args_.Ctx, (*in_).VectorUint8, (*in_).VectorUint16, (*in_).VectorUint32, (*in_).VectorUint64, (*in_).VectorInt8, (*in_).VectorInt16, (*in_).VectorInt32, (*in_).VectorInt64, (*in_).VectorFloat32, (*in_).VectorFloat64, (*in_).VectorString, (*in_).VectorOptString) |
| return nil, false, err_ |
| case ProtocolTwoWayVectorBasicOrdinal: |
| in_ := &VectorBasic{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| vectorUint8, vectorUint16, vectorUint32, vectorUint64, vectorInt8, vectorInt16, vectorInt32, vectorInt64, vectorFloat32, vectorFloat64, vectorString, vectorOptString, err_ := s_.Impl.TwoWayVectorBasic(args_.Ctx, (*in_).VectorUint8, (*in_).VectorUint16, (*in_).VectorUint32, (*in_).VectorUint64, (*in_).VectorInt8, (*in_).VectorInt16, (*in_).VectorInt32, (*in_).VectorInt64, (*in_).VectorFloat32, (*in_).VectorFloat64, (*in_).VectorString, (*in_).VectorOptString) |
| out_ := &VectorBasic{VectorUint8: vectorUint8, VectorUint16: vectorUint16, VectorUint32: vectorUint32, VectorUint64: vectorUint64, VectorInt8: vectorInt8, VectorInt16: vectorInt16, VectorInt32: vectorInt32, VectorInt64: vectorInt64, VectorFloat32: vectorFloat32, VectorFloat64: vectorFloat64, VectorString: vectorString, VectorOptString: vectorOptString} |
| return out_, true, err_ |
| case ProtocolErrorVectorBasicOrdinal: |
| payload, err_ := s_.Impl.ErrorVectorBasic(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayVectorCompoundOrdinal: |
| in_ := &VectorCompound{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayVectorCompound(args_.Ctx, (*in_).VectorBits, (*in_).VectorEnum, (*in_).VectorStruct, (*in_).VectorTable, (*in_).VectorUnion, (*in_).VectorOptStruct, (*in_).VectorOptUnion) |
| return nil, false, err_ |
| case ProtocolTwoWayVectorCompoundOrdinal: |
| in_ := &VectorCompound{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| vectorBits, vectorEnum, vectorStruct, vectorTable, vectorUnion, vectorOptStruct, vectorOptUnion, err_ := s_.Impl.TwoWayVectorCompound(args_.Ctx, (*in_).VectorBits, (*in_).VectorEnum, (*in_).VectorStruct, (*in_).VectorTable, (*in_).VectorUnion, (*in_).VectorOptStruct, (*in_).VectorOptUnion) |
| out_ := &VectorCompound{VectorBits: vectorBits, VectorEnum: vectorEnum, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion, VectorOptStruct: vectorOptStruct, VectorOptUnion: vectorOptUnion} |
| return out_, true, err_ |
| case ProtocolErrorVectorCompoundOrdinal: |
| payload, err_ := s_.Impl.ErrorVectorCompound(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayVectorOptionalOrdinal: |
| in_ := &VectorOptional{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayVectorOptional(args_.Ctx, (*in_).OptVectorUint8, (*in_).OptVectorString, (*in_).OptVectorStruct, (*in_).OptVectorOptStruct) |
| return nil, false, err_ |
| case ProtocolTwoWayVectorOptionalOrdinal: |
| in_ := &VectorOptional{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| optVectorUint8, optVectorString, optVectorStruct, optVectorOptStruct, err_ := s_.Impl.TwoWayVectorOptional(args_.Ctx, (*in_).OptVectorUint8, (*in_).OptVectorString, (*in_).OptVectorStruct, (*in_).OptVectorOptStruct) |
| out_ := &VectorOptional{OptVectorUint8: optVectorUint8, OptVectorString: optVectorString, OptVectorStruct: optVectorStruct, OptVectorOptStruct: optVectorOptStruct} |
| return out_, true, err_ |
| case ProtocolErrorVectorOptionalOrdinal: |
| payload, err_ := s_.Impl.ErrorVectorOptional(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayArrayVectorNestedOrdinal: |
| in_ := &ArrayVectorNested{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayArrayVectorNested(args_.Ctx, (*in_).ArrayArrayUint8, (*in_).ArrayVectorUint8, (*in_).VectorArrayUint8, (*in_).VectorVectorUint8) |
| return nil, false, err_ |
| case ProtocolTwoWayArrayVectorNestedOrdinal: |
| in_ := &ArrayVectorNested{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| arrayArrayUint8, arrayVectorUint8, vectorArrayUint8, vectorVectorUint8, err_ := s_.Impl.TwoWayArrayVectorNested(args_.Ctx, (*in_).ArrayArrayUint8, (*in_).ArrayVectorUint8, (*in_).VectorArrayUint8, (*in_).VectorVectorUint8) |
| out_ := &ArrayVectorNested{ArrayArrayUint8: arrayArrayUint8, ArrayVectorUint8: arrayVectorUint8, VectorArrayUint8: vectorArrayUint8, VectorVectorUint8: vectorVectorUint8} |
| return out_, true, err_ |
| case ProtocolErrorArrayVectorNestedOrdinal: |
| payload, err_ := s_.Impl.ErrorArrayVectorNested(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| case ProtocolOneWayResourceOrdinal: |
| in_ := &Resource{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| err_ := s_.Impl.OneWayResource(args_.Ctx, (*in_).Handle, (*in_).Vmo, (*in_).ClientEnd, (*in_).ServerEnd, (*in_).Struct, (*in_).Table, (*in_).Union, (*in_).OptHandle, (*in_).OptVmo, (*in_).OptClientEnd, (*in_).OptServerEnd, (*in_).OptStruct, (*in_).OptUnion, (*in_).ArrayHandle, (*in_).ArrayVmo, (*in_).ArrayClientEnd, (*in_).ArrayServerEnd, (*in_).ArrayStruct, (*in_).ArrayTable, (*in_).ArrayUnion, (*in_).VectorHandle, (*in_).VectorVmo, (*in_).VectorClientEnd, (*in_).VectorServerEnd, (*in_).VectorStruct, (*in_).VectorTable, (*in_).VectorUnion) |
| return nil, false, err_ |
| case ProtocolTwoWayResourceOrdinal: |
| in_ := &Resource{} |
| marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx) |
| if !ok { |
| return nil, false, _bindings.ErrMissingMarshalerContext |
| } |
| if err_ := _bindings.Unmarshal(marshalerCtx, args_.Bytes, args_.HandleInfos, in_); err_ != nil { |
| return nil, false, err_ |
| } |
| handle, vmo, clientEnd, serverEnd, struct_, table, union, optHandle, optVmo, optClientEnd, optServerEnd, optStruct, optUnion, arrayHandle, arrayVmo, arrayClientEnd, arrayServerEnd, arrayStruct, arrayTable, arrayUnion, vectorHandle, vectorVmo, vectorClientEnd, vectorServerEnd, vectorStruct, vectorTable, vectorUnion, err_ := s_.Impl.TwoWayResource(args_.Ctx, (*in_).Handle, (*in_).Vmo, (*in_).ClientEnd, (*in_).ServerEnd, (*in_).Struct, (*in_).Table, (*in_).Union, (*in_).OptHandle, (*in_).OptVmo, (*in_).OptClientEnd, (*in_).OptServerEnd, (*in_).OptStruct, (*in_).OptUnion, (*in_).ArrayHandle, (*in_).ArrayVmo, (*in_).ArrayClientEnd, (*in_).ArrayServerEnd, (*in_).ArrayStruct, (*in_).ArrayTable, (*in_).ArrayUnion, (*in_).VectorHandle, (*in_).VectorVmo, (*in_).VectorClientEnd, (*in_).VectorServerEnd, (*in_).VectorStruct, (*in_).VectorTable, (*in_).VectorUnion) |
| out_ := &Resource{Handle: handle, Vmo: vmo, ClientEnd: clientEnd, ServerEnd: serverEnd, Struct: struct_, Table: table, Union: union, OptHandle: optHandle, OptVmo: optVmo, OptClientEnd: optClientEnd, OptServerEnd: optServerEnd, OptStruct: optStruct, OptUnion: optUnion, ArrayHandle: arrayHandle, ArrayVmo: arrayVmo, ArrayClientEnd: arrayClientEnd, ArrayServerEnd: arrayServerEnd, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, VectorHandle: vectorHandle, VectorVmo: vectorVmo, VectorClientEnd: vectorClientEnd, VectorServerEnd: vectorServerEnd, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion} |
| return out_, true, err_ |
| case ProtocolErrorResourceOrdinal: |
| payload, err_ := s_.Impl.ErrorResource(args_.Ctx) |
| out_ := &payload |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type ProtocolEventProxy _bindings.ChannelProxy |
| |
| func (p *ProtocolEventProxy) EventBasic(uint8_ uint8, uint16_ uint16, uint32_ uint32, uint64_ uint64, int8_ int8, int16_ int16, int32_ int32, int64_ int64, float32 float32, float64 float64, string_ string, optString *string) error { |
| event_ := &Basic{Uint8: uint8_, Uint16: uint16_, Uint32: uint32_, Uint64: uint64_, Int8: int8_, Int16: int16_, Int32: int32_, Int64: int64_, Float32: float32, Float64: float64, String: string_, OptString: optString} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventBasicOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventCompound(bits Bits, enum Enum, struct_ Struct, table Table, union Union, optStruct *Struct, optUnion *Union) error { |
| event_ := &Compound{Bits: bits, Enum: enum, Struct: struct_, Table: table, Union: union, OptStruct: optStruct, OptUnion: optUnion} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventCompoundOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventArrayBasic(arrayUint8 [5]uint8, arrayUint16 [5]uint16, arrayUint32 [5]uint32, arrayUint64 [5]uint64, arrayInt8 [5]int8, arrayInt16 [5]int16, arrayInt32 [5]int32, arrayInt64 [5]int64, arrayFloat32 [5]float32, arrayFloat64 [5]float64, arrayString [5]string, arrayOptString [5]*string) error { |
| event_ := &ArrayBasic{ArrayUint8: arrayUint8, ArrayUint16: arrayUint16, ArrayUint32: arrayUint32, ArrayUint64: arrayUint64, ArrayInt8: arrayInt8, ArrayInt16: arrayInt16, ArrayInt32: arrayInt32, ArrayInt64: arrayInt64, ArrayFloat32: arrayFloat32, ArrayFloat64: arrayFloat64, ArrayString: arrayString, ArrayOptString: arrayOptString} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventArrayBasicOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventArrayCompound(arrayBits [5]Bits, arrayEnum [5]Enum, arrayStruct [5]Struct, arrayTable [5]Table, arrayUnion [5]Union, arrayOptStruct [5]*Struct, arrayOptUnion [5]*Union) error { |
| event_ := &ArrayCompound{ArrayBits: arrayBits, ArrayEnum: arrayEnum, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, ArrayOptStruct: arrayOptStruct, ArrayOptUnion: arrayOptUnion} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventArrayCompoundOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventVectorBasic(vectorUint8 []uint8, vectorUint16 []uint16, vectorUint32 []uint32, vectorUint64 []uint64, vectorInt8 []int8, vectorInt16 []int16, vectorInt32 []int32, vectorInt64 []int64, vectorFloat32 []float32, vectorFloat64 []float64, vectorString []string, vectorOptString []*string) error { |
| event_ := &VectorBasic{VectorUint8: vectorUint8, VectorUint16: vectorUint16, VectorUint32: vectorUint32, VectorUint64: vectorUint64, VectorInt8: vectorInt8, VectorInt16: vectorInt16, VectorInt32: vectorInt32, VectorInt64: vectorInt64, VectorFloat32: vectorFloat32, VectorFloat64: vectorFloat64, VectorString: vectorString, VectorOptString: vectorOptString} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventVectorBasicOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventVectorCompound(vectorBits []Bits, vectorEnum []Enum, vectorStruct []Struct, vectorTable []Table, vectorUnion []Union, vectorOptStruct []*Struct, vectorOptUnion []*Union) error { |
| event_ := &VectorCompound{VectorBits: vectorBits, VectorEnum: vectorEnum, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion, VectorOptStruct: vectorOptStruct, VectorOptUnion: vectorOptUnion} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventVectorCompoundOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventVectorOptional(optVectorUint8 *[]uint8, optVectorString *[]string, optVectorStruct *[]Struct, optVectorOptStruct *[]*Struct) error { |
| event_ := &VectorOptional{OptVectorUint8: optVectorUint8, OptVectorString: optVectorString, OptVectorStruct: optVectorStruct, OptVectorOptStruct: optVectorOptStruct} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventVectorOptionalOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventArrayVectorNested(arrayArrayUint8 [5][5]uint8, arrayVectorUint8 [5][]uint8, vectorArrayUint8 [][5]uint8, vectorVectorUint8 [][]uint8) error { |
| event_ := &ArrayVectorNested{ArrayArrayUint8: arrayArrayUint8, ArrayVectorUint8: arrayVectorUint8, VectorArrayUint8: vectorArrayUint8, VectorVectorUint8: vectorVectorUint8} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventArrayVectorNestedOrdinal, event_) |
| } |
| func (p *ProtocolEventProxy) EventResource(handle _zx.Handle, vmo _zx.VMO, clientEnd ProtocolWithCtxInterface, serverEnd ProtocolWithCtxInterfaceRequest, struct_ ResourceStruct, table ResourceTable, union ResourceUnion, optHandle _zx.Handle, optVmo _zx.VMO, optClientEnd ProtocolWithCtxInterface, optServerEnd ProtocolWithCtxInterfaceRequest, optStruct *ResourceStruct, optUnion *ResourceUnion, arrayHandle [5]_zx.Handle, arrayVmo [5]_zx.VMO, arrayClientEnd [5]ProtocolWithCtxInterface, arrayServerEnd [5]ProtocolWithCtxInterfaceRequest, arrayStruct [5]ResourceStruct, arrayTable [5]ResourceTable, arrayUnion [5]ResourceUnion, vectorHandle []_zx.Handle, vectorVmo []_zx.VMO, vectorClientEnd []ProtocolWithCtxInterface, vectorServerEnd []ProtocolWithCtxInterfaceRequest, vectorStruct []ResourceStruct, vectorTable []ResourceTable, vectorUnion []ResourceUnion) error { |
| event_ := &Resource{Handle: handle, Vmo: vmo, ClientEnd: clientEnd, ServerEnd: serverEnd, Struct: struct_, Table: table, Union: union, OptHandle: optHandle, OptVmo: optVmo, OptClientEnd: optClientEnd, OptServerEnd: optServerEnd, OptStruct: optStruct, OptUnion: optUnion, ArrayHandle: arrayHandle, ArrayVmo: arrayVmo, ArrayClientEnd: arrayClientEnd, ArrayServerEnd: arrayServerEnd, ArrayStruct: arrayStruct, ArrayTable: arrayTable, ArrayUnion: arrayUnion, VectorHandle: vectorHandle, VectorVmo: vectorVmo, VectorClientEnd: vectorClientEnd, VectorServerEnd: vectorServerEnd, VectorStruct: vectorStruct, VectorTable: vectorTable, VectorUnion: vectorUnion} |
| return ((*_bindings.ChannelProxy)(p)).Send(ProtocolEventResourceOrdinal, event_) |
| } |
