| // Code generated by fidlgen; DO NOT EDIT. |
| |
| package protocolpayloads |
| |
| import ( |
| testprotocolpayloadsimported "fidl/test/protocolpayloads/imported" |
| _bindings "syscall/zx/fidl" |
| ) |
| |
| type LocalStructPayload struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mLocalStructPayload = _bindings.CreateLazyMarshaler(LocalStructPayload{}) |
| |
| func (msg *LocalStructPayload) Marshaler() _bindings.Marshaler { |
| return _mLocalStructPayload |
| } |
| |
| type MainProtocolOnAnonWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mMainProtocolOnAnonWithErrorResponse = _bindings.CreateLazyMarshaler(MainProtocolOnAnonWithErrorResponse{}) |
| |
| func (msg *MainProtocolOnAnonWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolOnAnonWithErrorResponse |
| } |
| |
| type MainProtocolTwoWayAnonWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mMainProtocolTwoWayAnonWithErrorResponse = _bindings.CreateLazyMarshaler(MainProtocolTwoWayAnonWithErrorResponse{}) |
| |
| func (msg *MainProtocolTwoWayAnonWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolTwoWayAnonWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxTwoWayComposedWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result testprotocolpayloadsimported.ComposedProtocolTwoWayComposedWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxTwoWayComposedWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxTwoWayComposedWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxTwoWayComposedWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxTwoWayComposedWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxOnComposedWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result testprotocolpayloadsimported.ComposedProtocolOnComposedWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxOnComposedWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxOnComposedWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxOnComposedWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxOnComposedWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxTwoWayLocalWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result MainProtocolTwoWayLocalWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxTwoWayLocalWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxTwoWayLocalWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxTwoWayLocalWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxTwoWayLocalWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxOnLocalWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result MainProtocolOnLocalWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxOnLocalWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxOnLocalWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxOnLocalWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxOnLocalWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxTwoWayImportWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result MainProtocolTwoWayImportWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxTwoWayImportWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxTwoWayImportWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxTwoWayImportWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxTwoWayImportWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxOnImportWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result MainProtocolOnImportWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxOnImportWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxOnImportWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxOnImportWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxOnImportWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxOneWayAnonRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mmainProtocolWithCtxOneWayAnonRequest = _bindings.CreateLazyMarshaler(mainProtocolWithCtxOneWayAnonRequest{}) |
| |
| func (msg *mainProtocolWithCtxOneWayAnonRequest) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxOneWayAnonRequest |
| } |
| |
| type mainProtocolWithCtxTwoWayAnonRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mmainProtocolWithCtxTwoWayAnonRequest = _bindings.CreateLazyMarshaler(mainProtocolWithCtxTwoWayAnonRequest{}) |
| |
| func (msg *mainProtocolWithCtxTwoWayAnonRequest) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxTwoWayAnonRequest |
| } |
| |
| type mainProtocolWithCtxTwoWayAnonResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mmainProtocolWithCtxTwoWayAnonResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxTwoWayAnonResponse{}) |
| |
| func (msg *mainProtocolWithCtxTwoWayAnonResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxTwoWayAnonResponse |
| } |
| |
| type mainProtocolWithCtxTwoWayAnonWithErrorRequest struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mmainProtocolWithCtxTwoWayAnonWithErrorRequest = _bindings.CreateLazyMarshaler(mainProtocolWithCtxTwoWayAnonWithErrorRequest{}) |
| |
| func (msg *mainProtocolWithCtxTwoWayAnonWithErrorRequest) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxTwoWayAnonWithErrorRequest |
| } |
| |
| type mainProtocolWithCtxTwoWayAnonWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result MainProtocolTwoWayAnonWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxTwoWayAnonWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxTwoWayAnonWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxTwoWayAnonWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxTwoWayAnonWithErrorResponse |
| } |
| |
| type mainProtocolWithCtxOnAnonResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"8" fidl_alignment_v2:"4"` |
| A uint32 `fidl_offset_v2:"0"` |
| B uint32 `fidl_offset_v2:"4"` |
| } |
| |
| var _mmainProtocolWithCtxOnAnonResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxOnAnonResponse{}) |
| |
| func (msg *mainProtocolWithCtxOnAnonResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxOnAnonResponse |
| } |
| |
| type mainProtocolWithCtxOnAnonWithErrorResponse struct { |
| _ struct{} `fidl:"s" fidl_size_v2:"16" fidl_alignment_v2:"8"` |
| Result MainProtocolOnAnonWithErrorResult `fidl_offset_v2:"0"` |
| } |
| |
| var _mmainProtocolWithCtxOnAnonWithErrorResponse = _bindings.CreateLazyMarshaler(mainProtocolWithCtxOnAnonWithErrorResponse{}) |
| |
| func (msg *mainProtocolWithCtxOnAnonWithErrorResponse) Marshaler() _bindings.Marshaler { |
| return _mmainProtocolWithCtxOnAnonWithErrorResponse |
| } |
| |
| type I_mainProtocolOnAnonWithErrorResultTag uint64 |
| |
| const ( |
| MainProtocolOnAnonWithErrorResultResponse = 1 // 0x00000001 |
| MainProtocolOnAnonWithErrorResultErr = 2 // 0x00000002 |
| ) |
| |
| type MainProtocolOnAnonWithErrorResult struct { |
| I_mainProtocolOnAnonWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response MainProtocolOnAnonWithErrorResponse `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mMainProtocolOnAnonWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolOnAnonWithErrorResult{}) |
| |
| func (msg *MainProtocolOnAnonWithErrorResult) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolOnAnonWithErrorResult |
| } |
| |
| func (_m *MainProtocolOnAnonWithErrorResult) reset() { |
| switch _m.I_mainProtocolOnAnonWithErrorResultTag { |
| case 1: |
| var _zeroed MainProtocolOnAnonWithErrorResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *MainProtocolOnAnonWithErrorResult) Which() I_mainProtocolOnAnonWithErrorResultTag { |
| return _m.I_mainProtocolOnAnonWithErrorResultTag |
| } |
| |
| func (_m *MainProtocolOnAnonWithErrorResult) Ordinal() uint64 { |
| return uint64(_m.I_mainProtocolOnAnonWithErrorResultTag) |
| } |
| |
| func (_m *MainProtocolOnAnonWithErrorResult) SetResponse(response MainProtocolOnAnonWithErrorResponse) { |
| _m.reset() |
| _m.I_mainProtocolOnAnonWithErrorResultTag = MainProtocolOnAnonWithErrorResultResponse |
| _m.Response = response |
| } |
| |
| func MainProtocolOnAnonWithErrorResultWithResponse(response MainProtocolOnAnonWithErrorResponse) MainProtocolOnAnonWithErrorResult { |
| var _u MainProtocolOnAnonWithErrorResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *MainProtocolOnAnonWithErrorResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_mainProtocolOnAnonWithErrorResultTag = MainProtocolOnAnonWithErrorResultErr |
| _m.Err = err |
| } |
| |
| func MainProtocolOnAnonWithErrorResultWithErr(err uint32) MainProtocolOnAnonWithErrorResult { |
| var _u MainProtocolOnAnonWithErrorResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_mainProtocolOnImportWithErrorResultTag uint64 |
| |
| const ( |
| MainProtocolOnImportWithErrorResultResponse = 1 // 0x00000001 |
| MainProtocolOnImportWithErrorResultErr = 2 // 0x00000002 |
| ) |
| |
| type MainProtocolOnImportWithErrorResult struct { |
| I_mainProtocolOnImportWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response testprotocolpayloadsimported.ImportStructPayload `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mMainProtocolOnImportWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolOnImportWithErrorResult{}) |
| |
| func (msg *MainProtocolOnImportWithErrorResult) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolOnImportWithErrorResult |
| } |
| |
| func (_m *MainProtocolOnImportWithErrorResult) reset() { |
| switch _m.I_mainProtocolOnImportWithErrorResultTag { |
| case 1: |
| var _zeroed testprotocolpayloadsimported.ImportStructPayload |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *MainProtocolOnImportWithErrorResult) Which() I_mainProtocolOnImportWithErrorResultTag { |
| return _m.I_mainProtocolOnImportWithErrorResultTag |
| } |
| |
| func (_m *MainProtocolOnImportWithErrorResult) Ordinal() uint64 { |
| return uint64(_m.I_mainProtocolOnImportWithErrorResultTag) |
| } |
| |
| func (_m *MainProtocolOnImportWithErrorResult) SetResponse(response testprotocolpayloadsimported.ImportStructPayload) { |
| _m.reset() |
| _m.I_mainProtocolOnImportWithErrorResultTag = MainProtocolOnImportWithErrorResultResponse |
| _m.Response = response |
| } |
| |
| func MainProtocolOnImportWithErrorResultWithResponse(response testprotocolpayloadsimported.ImportStructPayload) MainProtocolOnImportWithErrorResult { |
| var _u MainProtocolOnImportWithErrorResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *MainProtocolOnImportWithErrorResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_mainProtocolOnImportWithErrorResultTag = MainProtocolOnImportWithErrorResultErr |
| _m.Err = err |
| } |
| |
| func MainProtocolOnImportWithErrorResultWithErr(err uint32) MainProtocolOnImportWithErrorResult { |
| var _u MainProtocolOnImportWithErrorResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_mainProtocolOnLocalWithErrorResultTag uint64 |
| |
| const ( |
| MainProtocolOnLocalWithErrorResultResponse = 1 // 0x00000001 |
| MainProtocolOnLocalWithErrorResultErr = 2 // 0x00000002 |
| ) |
| |
| type MainProtocolOnLocalWithErrorResult struct { |
| I_mainProtocolOnLocalWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response LocalStructPayload `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mMainProtocolOnLocalWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolOnLocalWithErrorResult{}) |
| |
| func (msg *MainProtocolOnLocalWithErrorResult) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolOnLocalWithErrorResult |
| } |
| |
| func (_m *MainProtocolOnLocalWithErrorResult) reset() { |
| switch _m.I_mainProtocolOnLocalWithErrorResultTag { |
| case 1: |
| var _zeroed LocalStructPayload |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *MainProtocolOnLocalWithErrorResult) Which() I_mainProtocolOnLocalWithErrorResultTag { |
| return _m.I_mainProtocolOnLocalWithErrorResultTag |
| } |
| |
| func (_m *MainProtocolOnLocalWithErrorResult) Ordinal() uint64 { |
| return uint64(_m.I_mainProtocolOnLocalWithErrorResultTag) |
| } |
| |
| func (_m *MainProtocolOnLocalWithErrorResult) SetResponse(response LocalStructPayload) { |
| _m.reset() |
| _m.I_mainProtocolOnLocalWithErrorResultTag = MainProtocolOnLocalWithErrorResultResponse |
| _m.Response = response |
| } |
| |
| func MainProtocolOnLocalWithErrorResultWithResponse(response LocalStructPayload) MainProtocolOnLocalWithErrorResult { |
| var _u MainProtocolOnLocalWithErrorResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *MainProtocolOnLocalWithErrorResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_mainProtocolOnLocalWithErrorResultTag = MainProtocolOnLocalWithErrorResultErr |
| _m.Err = err |
| } |
| |
| func MainProtocolOnLocalWithErrorResultWithErr(err uint32) MainProtocolOnLocalWithErrorResult { |
| var _u MainProtocolOnLocalWithErrorResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_mainProtocolTwoWayAnonWithErrorResultTag uint64 |
| |
| const ( |
| MainProtocolTwoWayAnonWithErrorResultResponse = 1 // 0x00000001 |
| MainProtocolTwoWayAnonWithErrorResultErr = 2 // 0x00000002 |
| ) |
| |
| type MainProtocolTwoWayAnonWithErrorResult struct { |
| I_mainProtocolTwoWayAnonWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response MainProtocolTwoWayAnonWithErrorResponse `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mMainProtocolTwoWayAnonWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolTwoWayAnonWithErrorResult{}) |
| |
| func (msg *MainProtocolTwoWayAnonWithErrorResult) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolTwoWayAnonWithErrorResult |
| } |
| |
| func (_m *MainProtocolTwoWayAnonWithErrorResult) reset() { |
| switch _m.I_mainProtocolTwoWayAnonWithErrorResultTag { |
| case 1: |
| var _zeroed MainProtocolTwoWayAnonWithErrorResponse |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *MainProtocolTwoWayAnonWithErrorResult) Which() I_mainProtocolTwoWayAnonWithErrorResultTag { |
| return _m.I_mainProtocolTwoWayAnonWithErrorResultTag |
| } |
| |
| func (_m *MainProtocolTwoWayAnonWithErrorResult) Ordinal() uint64 { |
| return uint64(_m.I_mainProtocolTwoWayAnonWithErrorResultTag) |
| } |
| |
| func (_m *MainProtocolTwoWayAnonWithErrorResult) SetResponse(response MainProtocolTwoWayAnonWithErrorResponse) { |
| _m.reset() |
| _m.I_mainProtocolTwoWayAnonWithErrorResultTag = MainProtocolTwoWayAnonWithErrorResultResponse |
| _m.Response = response |
| } |
| |
| func MainProtocolTwoWayAnonWithErrorResultWithResponse(response MainProtocolTwoWayAnonWithErrorResponse) MainProtocolTwoWayAnonWithErrorResult { |
| var _u MainProtocolTwoWayAnonWithErrorResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *MainProtocolTwoWayAnonWithErrorResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_mainProtocolTwoWayAnonWithErrorResultTag = MainProtocolTwoWayAnonWithErrorResultErr |
| _m.Err = err |
| } |
| |
| func MainProtocolTwoWayAnonWithErrorResultWithErr(err uint32) MainProtocolTwoWayAnonWithErrorResult { |
| var _u MainProtocolTwoWayAnonWithErrorResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_mainProtocolTwoWayImportWithErrorResultTag uint64 |
| |
| const ( |
| MainProtocolTwoWayImportWithErrorResultResponse = 1 // 0x00000001 |
| MainProtocolTwoWayImportWithErrorResultErr = 2 // 0x00000002 |
| ) |
| |
| type MainProtocolTwoWayImportWithErrorResult struct { |
| I_mainProtocolTwoWayImportWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response testprotocolpayloadsimported.ImportStructPayload `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mMainProtocolTwoWayImportWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolTwoWayImportWithErrorResult{}) |
| |
| func (msg *MainProtocolTwoWayImportWithErrorResult) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolTwoWayImportWithErrorResult |
| } |
| |
| func (_m *MainProtocolTwoWayImportWithErrorResult) reset() { |
| switch _m.I_mainProtocolTwoWayImportWithErrorResultTag { |
| case 1: |
| var _zeroed testprotocolpayloadsimported.ImportStructPayload |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *MainProtocolTwoWayImportWithErrorResult) Which() I_mainProtocolTwoWayImportWithErrorResultTag { |
| return _m.I_mainProtocolTwoWayImportWithErrorResultTag |
| } |
| |
| func (_m *MainProtocolTwoWayImportWithErrorResult) Ordinal() uint64 { |
| return uint64(_m.I_mainProtocolTwoWayImportWithErrorResultTag) |
| } |
| |
| func (_m *MainProtocolTwoWayImportWithErrorResult) SetResponse(response testprotocolpayloadsimported.ImportStructPayload) { |
| _m.reset() |
| _m.I_mainProtocolTwoWayImportWithErrorResultTag = MainProtocolTwoWayImportWithErrorResultResponse |
| _m.Response = response |
| } |
| |
| func MainProtocolTwoWayImportWithErrorResultWithResponse(response testprotocolpayloadsimported.ImportStructPayload) MainProtocolTwoWayImportWithErrorResult { |
| var _u MainProtocolTwoWayImportWithErrorResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *MainProtocolTwoWayImportWithErrorResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_mainProtocolTwoWayImportWithErrorResultTag = MainProtocolTwoWayImportWithErrorResultErr |
| _m.Err = err |
| } |
| |
| func MainProtocolTwoWayImportWithErrorResultWithErr(err uint32) MainProtocolTwoWayImportWithErrorResult { |
| var _u MainProtocolTwoWayImportWithErrorResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| type I_mainProtocolTwoWayLocalWithErrorResultTag uint64 |
| |
| const ( |
| MainProtocolTwoWayLocalWithErrorResultResponse = 1 // 0x00000001 |
| MainProtocolTwoWayLocalWithErrorResultErr = 2 // 0x00000002 |
| ) |
| |
| type MainProtocolTwoWayLocalWithErrorResult struct { |
| I_mainProtocolTwoWayLocalWithErrorResultTag `fidl:"x!" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"` |
| Response LocalStructPayload `fidl_ordinal:"1"` |
| Err uint32 `fidl_ordinal:"2"` |
| } |
| |
| var _mMainProtocolTwoWayLocalWithErrorResult = _bindings.CreateLazyMarshaler(MainProtocolTwoWayLocalWithErrorResult{}) |
| |
| func (msg *MainProtocolTwoWayLocalWithErrorResult) Marshaler() _bindings.Marshaler { |
| return _mMainProtocolTwoWayLocalWithErrorResult |
| } |
| |
| func (_m *MainProtocolTwoWayLocalWithErrorResult) reset() { |
| switch _m.I_mainProtocolTwoWayLocalWithErrorResultTag { |
| case 1: |
| var _zeroed LocalStructPayload |
| _m.Response = _zeroed |
| case 2: |
| var _zeroed uint32 |
| _m.Err = _zeroed |
| } |
| } |
| |
| func (_m *MainProtocolTwoWayLocalWithErrorResult) Which() I_mainProtocolTwoWayLocalWithErrorResultTag { |
| return _m.I_mainProtocolTwoWayLocalWithErrorResultTag |
| } |
| |
| func (_m *MainProtocolTwoWayLocalWithErrorResult) Ordinal() uint64 { |
| return uint64(_m.I_mainProtocolTwoWayLocalWithErrorResultTag) |
| } |
| |
| func (_m *MainProtocolTwoWayLocalWithErrorResult) SetResponse(response LocalStructPayload) { |
| _m.reset() |
| _m.I_mainProtocolTwoWayLocalWithErrorResultTag = MainProtocolTwoWayLocalWithErrorResultResponse |
| _m.Response = response |
| } |
| |
| func MainProtocolTwoWayLocalWithErrorResultWithResponse(response LocalStructPayload) MainProtocolTwoWayLocalWithErrorResult { |
| var _u MainProtocolTwoWayLocalWithErrorResult |
| _u.SetResponse(response) |
| return _u |
| } |
| |
| func (_m *MainProtocolTwoWayLocalWithErrorResult) SetErr(err uint32) { |
| _m.reset() |
| _m.I_mainProtocolTwoWayLocalWithErrorResultTag = MainProtocolTwoWayLocalWithErrorResultErr |
| _m.Err = err |
| } |
| |
| func MainProtocolTwoWayLocalWithErrorResultWithErr(err uint32) MainProtocolTwoWayLocalWithErrorResult { |
| var _u MainProtocolTwoWayLocalWithErrorResult |
| _u.SetErr(err) |
| return _u |
| } |
| |
| const ( |
| MainProtocolOneWayComposedOrdinal uint64 = 0x241e4384443ccb10 |
| MainProtocolTwoWayComposedOrdinal uint64 = 0x2348a1331ca4cfb0 |
| MainProtocolTwoWayComposedWithErrorOrdinal uint64 = 0x6a9be48b574d1557 |
| MainProtocolOnComposedOrdinal uint64 = 0x19fbe2b2f6f9273a |
| MainProtocolOnComposedWithErrorOrdinal uint64 = 0x63774db677215e98 |
| MainProtocolOneWayLocalOrdinal uint64 = 0x6b9feaf9305b0715 |
| MainProtocolTwoWayLocalOrdinal uint64 = 0x743776548de3af0f |
| MainProtocolTwoWayLocalWithErrorOrdinal uint64 = 0x2839c029915cb8fc |
| MainProtocolOnLocalOrdinal uint64 = 0x4745f7438cd80819 |
| MainProtocolOnLocalWithErrorOrdinal uint64 = 0x4ecd4b3982e221af |
| MainProtocolOneWayImportOrdinal uint64 = 0x2e6b091ae4cee40c |
| MainProtocolTwoWayImportOrdinal uint64 = 0x20f4a8f65ff69473 |
| MainProtocolTwoWayImportWithErrorOrdinal uint64 = 0x3b7b706d42eb9bbd |
| MainProtocolOnImportOrdinal uint64 = 0x1bb4f4c30b6f8909 |
| MainProtocolOnImportWithErrorOrdinal uint64 = 0x6292b793d728f205 |
| MainProtocolOneWayAnonOrdinal uint64 = 0xb43565c01ab54ac |
| MainProtocolTwoWayAnonOrdinal uint64 = 0x8bdc969ff7dd759 |
| MainProtocolTwoWayAnonWithErrorOrdinal uint64 = 0x5862bf8170c87a36 |
| MainProtocolOnAnonOrdinal uint64 = 0x42d321dacc4df000 |
| MainProtocolOnAnonWithErrorOrdinal uint64 = 0x45bc24ef47b44a02 |
| ) |
| |
| type MainProtocolWithCtxInterface _bindings.ChannelProxy |
| |
| func (p *MainProtocolWithCtxInterface) OneWayComposed(ctx_ _bindings.Context, a int32) error { |
| req_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayComposedOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayComposed(ctx_ _bindings.Context, a int32) (int32, error) { |
| req_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| resp_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayComposedOrdinal, req_, resp_) |
| return (*resp_).A, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayComposedWithError(ctx_ _bindings.Context, a int32) (testprotocolpayloadsimported.ComposedProtocolTwoWayComposedWithErrorResult, error) { |
| req_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| resp_ := &mainProtocolWithCtxTwoWayComposedWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayComposedWithErrorOrdinal, req_, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnComposed(ctx_ _bindings.Context) (int32, error) { |
| resp_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnComposedOrdinal, resp_) |
| return (*resp_).A, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnComposedWithError(ctx_ _bindings.Context) (testprotocolpayloadsimported.ComposedProtocolOnComposedWithErrorResult, error) { |
| resp_ := &mainProtocolWithCtxOnComposedWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnComposedWithErrorOrdinal, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) OneWayLocal(ctx_ _bindings.Context, a uint32, b uint32) error { |
| req_ := &LocalStructPayload{A: a, B: b} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayLocalOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayLocal(ctx_ _bindings.Context, a uint32, b uint32) (uint32, uint32, error) { |
| req_ := &LocalStructPayload{A: a, B: b} |
| resp_ := &LocalStructPayload{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayLocalOrdinal, req_, resp_) |
| return (*resp_).A, (*resp_).B, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayLocalWithError(ctx_ _bindings.Context, a uint32, b uint32) (MainProtocolTwoWayLocalWithErrorResult, error) { |
| req_ := &LocalStructPayload{A: a, B: b} |
| resp_ := &mainProtocolWithCtxTwoWayLocalWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayLocalWithErrorOrdinal, req_, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnLocal(ctx_ _bindings.Context) (uint32, uint32, error) { |
| resp_ := &LocalStructPayload{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnLocalOrdinal, resp_) |
| return (*resp_).A, (*resp_).B, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnLocalWithError(ctx_ _bindings.Context) (MainProtocolOnLocalWithErrorResult, error) { |
| resp_ := &mainProtocolWithCtxOnLocalWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnLocalWithErrorOrdinal, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) OneWayImport(ctx_ _bindings.Context, a int32) error { |
| req_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayImportOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayImport(ctx_ _bindings.Context, a int32) (int32, error) { |
| req_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| resp_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayImportOrdinal, req_, resp_) |
| return (*resp_).A, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayImportWithError(ctx_ _bindings.Context, a int32) (MainProtocolTwoWayImportWithErrorResult, error) { |
| req_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| resp_ := &mainProtocolWithCtxTwoWayImportWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayImportWithErrorOrdinal, req_, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnImport(ctx_ _bindings.Context) (int32, error) { |
| resp_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnImportOrdinal, resp_) |
| return (*resp_).A, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnImportWithError(ctx_ _bindings.Context) (MainProtocolOnImportWithErrorResult, error) { |
| resp_ := &mainProtocolWithCtxOnImportWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnImportWithErrorOrdinal, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) OneWayAnon(ctx_ _bindings.Context, a uint32, b uint32) error { |
| req_ := &mainProtocolWithCtxOneWayAnonRequest{A: a, B: b} |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOneWayAnonOrdinal, req_) |
| return err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayAnon(ctx_ _bindings.Context, a uint32, b uint32) (uint32, uint32, error) { |
| req_ := &mainProtocolWithCtxTwoWayAnonRequest{A: a, B: b} |
| resp_ := &mainProtocolWithCtxTwoWayAnonResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayAnonOrdinal, req_, resp_) |
| return (*resp_).A, (*resp_).B, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) TwoWayAnonWithError(ctx_ _bindings.Context, a uint32, b uint32) (MainProtocolTwoWayAnonWithErrorResult, error) { |
| req_ := &mainProtocolWithCtxTwoWayAnonWithErrorRequest{A: a, B: b} |
| resp_ := &mainProtocolWithCtxTwoWayAnonWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Call(MainProtocolTwoWayAnonWithErrorOrdinal, req_, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnAnon(ctx_ _bindings.Context) (uint32, uint32, error) { |
| resp_ := &mainProtocolWithCtxOnAnonResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnAnonOrdinal, resp_) |
| return (*resp_).A, (*resp_).B, err_ |
| } |
| |
| func (p *MainProtocolWithCtxInterface) ExpectOnAnonWithError(ctx_ _bindings.Context) (MainProtocolOnAnonWithErrorResult, error) { |
| resp_ := &mainProtocolWithCtxOnAnonWithErrorResponse{} |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(MainProtocolOnAnonWithErrorOrdinal, resp_) |
| return (*resp_).Result, err_ |
| } |
| |
| type MainProtocolWithCtx interface { |
| OneWayComposed(ctx_ _bindings.Context, a int32) error |
| TwoWayComposed(ctx_ _bindings.Context, a int32) (int32, error) |
| TwoWayComposedWithError(ctx_ _bindings.Context, a int32) (testprotocolpayloadsimported.ComposedProtocolTwoWayComposedWithErrorResult, error) |
| OneWayLocal(ctx_ _bindings.Context, a uint32, b uint32) error |
| TwoWayLocal(ctx_ _bindings.Context, a uint32, b uint32) (uint32, uint32, error) |
| TwoWayLocalWithError(ctx_ _bindings.Context, a uint32, b uint32) (MainProtocolTwoWayLocalWithErrorResult, error) |
| OneWayImport(ctx_ _bindings.Context, a int32) error |
| TwoWayImport(ctx_ _bindings.Context, a int32) (int32, error) |
| TwoWayImportWithError(ctx_ _bindings.Context, a int32) (MainProtocolTwoWayImportWithErrorResult, error) |
| OneWayAnon(ctx_ _bindings.Context, a uint32, b uint32) error |
| TwoWayAnon(ctx_ _bindings.Context, a uint32, b uint32) (uint32, uint32, error) |
| TwoWayAnonWithError(ctx_ _bindings.Context, a uint32, b uint32) (MainProtocolTwoWayAnonWithErrorResult, error) |
| } |
| |
| type MainProtocolWithCtxTransitionalBase struct{} |
| |
| type MainProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewMainProtocolWithCtxInterfaceRequest() (MainProtocolWithCtxInterfaceRequest, *MainProtocolWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return MainProtocolWithCtxInterfaceRequest(req), (*MainProtocolWithCtxInterface)(cli), err |
| } |
| |
| type MainProtocolWithCtxStub struct { |
| Impl MainProtocolWithCtx |
| } |
| |
| func (s_ *MainProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case MainProtocolOneWayComposedOrdinal: |
| in_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| 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.OneWayComposed(args_.Ctx, (*in_).A) |
| return nil, false, err_ |
| case MainProtocolTwoWayComposedOrdinal: |
| in_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| 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_ |
| } |
| a, err_ := s_.Impl.TwoWayComposed(args_.Ctx, (*in_).A) |
| out_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| return out_, true, err_ |
| case MainProtocolTwoWayComposedWithErrorOrdinal: |
| in_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| 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_ |
| } |
| result, err_ := s_.Impl.TwoWayComposedWithError(args_.Ctx, (*in_).A) |
| out_ := &mainProtocolWithCtxTwoWayComposedWithErrorResponse{Result: result} |
| return out_, true, err_ |
| case MainProtocolOneWayLocalOrdinal: |
| in_ := &LocalStructPayload{} |
| 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.OneWayLocal(args_.Ctx, (*in_).A, (*in_).B) |
| return nil, false, err_ |
| case MainProtocolTwoWayLocalOrdinal: |
| in_ := &LocalStructPayload{} |
| 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_ |
| } |
| a, b, err_ := s_.Impl.TwoWayLocal(args_.Ctx, (*in_).A, (*in_).B) |
| out_ := &LocalStructPayload{A: a, B: b} |
| return out_, true, err_ |
| case MainProtocolTwoWayLocalWithErrorOrdinal: |
| in_ := &LocalStructPayload{} |
| 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_ |
| } |
| result, err_ := s_.Impl.TwoWayLocalWithError(args_.Ctx, (*in_).A, (*in_).B) |
| out_ := &mainProtocolWithCtxTwoWayLocalWithErrorResponse{Result: result} |
| return out_, true, err_ |
| case MainProtocolOneWayImportOrdinal: |
| in_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| 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.OneWayImport(args_.Ctx, (*in_).A) |
| return nil, false, err_ |
| case MainProtocolTwoWayImportOrdinal: |
| in_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| 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_ |
| } |
| a, err_ := s_.Impl.TwoWayImport(args_.Ctx, (*in_).A) |
| out_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| return out_, true, err_ |
| case MainProtocolTwoWayImportWithErrorOrdinal: |
| in_ := &testprotocolpayloadsimported.ImportStructPayload{} |
| 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_ |
| } |
| result, err_ := s_.Impl.TwoWayImportWithError(args_.Ctx, (*in_).A) |
| out_ := &mainProtocolWithCtxTwoWayImportWithErrorResponse{Result: result} |
| return out_, true, err_ |
| case MainProtocolOneWayAnonOrdinal: |
| in_ := &mainProtocolWithCtxOneWayAnonRequest{} |
| 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.OneWayAnon(args_.Ctx, (*in_).A, (*in_).B) |
| return nil, false, err_ |
| case MainProtocolTwoWayAnonOrdinal: |
| in_ := &mainProtocolWithCtxTwoWayAnonRequest{} |
| 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_ |
| } |
| a, b, err_ := s_.Impl.TwoWayAnon(args_.Ctx, (*in_).A, (*in_).B) |
| out_ := &mainProtocolWithCtxTwoWayAnonResponse{A: a, B: b} |
| return out_, true, err_ |
| case MainProtocolTwoWayAnonWithErrorOrdinal: |
| in_ := &mainProtocolWithCtxTwoWayAnonWithErrorRequest{} |
| 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_ |
| } |
| result, err_ := s_.Impl.TwoWayAnonWithError(args_.Ctx, (*in_).A, (*in_).B) |
| out_ := &mainProtocolWithCtxTwoWayAnonWithErrorResponse{Result: result} |
| return out_, true, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type MainProtocolEventProxy _bindings.ChannelProxy |
| |
| func (p *MainProtocolEventProxy) OnComposed(a int32) error { |
| event_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnComposedOrdinal, event_) |
| } |
| func (p *MainProtocolEventProxy) OnComposedWithError(result testprotocolpayloadsimported.ComposedProtocolOnComposedWithErrorResult) error { |
| event_ := &mainProtocolWithCtxOnComposedWithErrorResponse{Result: result} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnComposedWithErrorOrdinal, event_) |
| } |
| func (p *MainProtocolEventProxy) OnLocal(a uint32, b uint32) error { |
| event_ := &LocalStructPayload{A: a, B: b} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnLocalOrdinal, event_) |
| } |
| func (p *MainProtocolEventProxy) OnLocalWithError(result MainProtocolOnLocalWithErrorResult) error { |
| event_ := &mainProtocolWithCtxOnLocalWithErrorResponse{Result: result} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnLocalWithErrorOrdinal, event_) |
| } |
| func (p *MainProtocolEventProxy) OnImport(a int32) error { |
| event_ := &testprotocolpayloadsimported.ImportStructPayload{A: a} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnImportOrdinal, event_) |
| } |
| func (p *MainProtocolEventProxy) OnImportWithError(result MainProtocolOnImportWithErrorResult) error { |
| event_ := &mainProtocolWithCtxOnImportWithErrorResponse{Result: result} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnImportWithErrorOrdinal, event_) |
| } |
| func (p *MainProtocolEventProxy) OnAnon(a uint32, b uint32) error { |
| event_ := &mainProtocolWithCtxOnAnonResponse{A: a, B: b} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnAnonOrdinal, event_) |
| } |
| func (p *MainProtocolEventProxy) OnAnonWithError(result MainProtocolOnAnonWithErrorResult) error { |
| event_ := &mainProtocolWithCtxOnAnonWithErrorResponse{Result: result} |
| return ((*_bindings.ChannelProxy)(p)).Send(MainProtocolOnAnonWithErrorOrdinal, event_) |
| } |
