| // WARNING: This file is machine generated by fidlgen. |
| |
| package name |
| |
| |
| import ( |
| _zx "syscall/zx" |
| _bindings "syscall/zx/fidl" |
| ) |
| |
| |
| |
| |
| |
| type ErrorEnun uint32 |
| const ( |
| ErrorEnunErrFoo ErrorEnun = 1 |
| ErrorEnunErrBar ErrorEnun = 2 |
| ) |
| func (x ErrorEnun) String() string { |
| switch x { |
| case 1: |
| return "ErrFoo" |
| case 2: |
| return "ErrBar" |
| } |
| return "Unknown" |
| } |
| |
| type WithErrorSyntaxErrorAsPrimitiveResponse struct { |
| _ struct{} `fidl2:"s,1,1"` |
| } |
| |
| var _mWithErrorSyntaxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsPrimitiveResponse{}) |
| |
| func (msg *WithErrorSyntaxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler { |
| return _mWithErrorSyntaxErrorAsPrimitiveResponse |
| } |
| |
| type WithErrorSyntaxErrorAsEnumResponse struct { |
| _ struct{} `fidl2:"s,1,1"` |
| } |
| |
| var _mWithErrorSyntaxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsEnumResponse{}) |
| |
| func (msg *WithErrorSyntaxErrorAsEnumResponse) Marshaler() _bindings.Marshaler { |
| return _mWithErrorSyntaxErrorAsEnumResponse |
| } |
| type WithErrorSyntaxErrorAsPrimitiveResultTag uint32 |
| const ( |
| _ WithErrorSyntaxErrorAsPrimitiveResultTag = iota |
| WithErrorSyntaxErrorAsPrimitiveResultResponse |
| WithErrorSyntaxErrorAsPrimitiveResultErr |
| ) |
| |
| |
| type WithErrorSyntaxErrorAsPrimitiveResult struct { |
| WithErrorSyntaxErrorAsPrimitiveResultTag `fidl:"tag" fidl2:"u,8,4"` |
| Response WithErrorSyntaxErrorAsPrimitiveResponse |
| Err uint32 |
| } |
| |
| func (u *WithErrorSyntaxErrorAsPrimitiveResult) Which() WithErrorSyntaxErrorAsPrimitiveResultTag { |
| return u.WithErrorSyntaxErrorAsPrimitiveResultTag |
| } |
| |
| func (u *WithErrorSyntaxErrorAsPrimitiveResult) SetResponse(response WithErrorSyntaxErrorAsPrimitiveResponse) { |
| u.WithErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultResponse |
| u.Response = response |
| } |
| |
| func (u *WithErrorSyntaxErrorAsPrimitiveResult) SetErr(err uint32) { |
| u.WithErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultErr |
| u.Err = err |
| } |
| type WithErrorSyntaxErrorAsEnumResultTag uint32 |
| const ( |
| _ WithErrorSyntaxErrorAsEnumResultTag = iota |
| WithErrorSyntaxErrorAsEnumResultResponse |
| WithErrorSyntaxErrorAsEnumResultErr |
| ) |
| |
| |
| type WithErrorSyntaxErrorAsEnumResult struct { |
| WithErrorSyntaxErrorAsEnumResultTag `fidl:"tag" fidl2:"u,8,4"` |
| Response WithErrorSyntaxErrorAsEnumResponse |
| Err ErrorEnun |
| } |
| |
| func (u *WithErrorSyntaxErrorAsEnumResult) Which() WithErrorSyntaxErrorAsEnumResultTag { |
| return u.WithErrorSyntaxErrorAsEnumResultTag |
| } |
| |
| func (u *WithErrorSyntaxErrorAsEnumResult) SetResponse(response WithErrorSyntaxErrorAsEnumResponse) { |
| u.WithErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultResponse |
| u.Response = response |
| } |
| |
| func (u *WithErrorSyntaxErrorAsEnumResult) SetErr(err ErrorEnun) { |
| u.WithErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultErr |
| u.Err = err |
| } |
| const ( |
| WithAndWithoutRequestResponseNoRequestNoResponseOrdinal uint32 = 503576693 |
| WithAndWithoutRequestResponseNoRequestNoResponseGenOrdinal uint32 = 503576693 |
| WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal uint32 = 1308023765 |
| WithAndWithoutRequestResponseNoRequestEmptyResponseGenOrdinal uint32 = 1308023765 |
| WithAndWithoutRequestResponseNoRequestWithResponseOrdinal uint32 = 107534328 |
| WithAndWithoutRequestResponseNoRequestWithResponseGenOrdinal uint32 = 107534328 |
| WithAndWithoutRequestResponseWithRequestNoResponseOrdinal uint32 = 432149361 |
| WithAndWithoutRequestResponseWithRequestNoResponseGenOrdinal uint32 = 432149361 |
| WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal uint32 = 1995585907 |
| WithAndWithoutRequestResponseWithRequestEmptyResponseGenOrdinal uint32 = 1995585907 |
| WithAndWithoutRequestResponseWithRequestWithResponseOrdinal uint32 = 426977568 |
| WithAndWithoutRequestResponseWithRequestWithResponseGenOrdinal uint32 = 426977568 |
| WithAndWithoutRequestResponseOnEmptyResponseOrdinal uint32 = 1769985842 |
| WithAndWithoutRequestResponseOnEmptyResponseGenOrdinal uint32 = 1769985842 |
| WithAndWithoutRequestResponseOnWithResponseOrdinal uint32 = 2051478023 |
| WithAndWithoutRequestResponseOnWithResponseGenOrdinal uint32 = 2051478023 |
| ) |
| |
| type withAndWithoutRequestResponseNoRequestWithResponseResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Ret string |
| } |
| |
| var _mwithAndWithoutRequestResponseNoRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseNoRequestWithResponseResponse{}) |
| |
| func (msg *withAndWithoutRequestResponseNoRequestWithResponseResponse) Marshaler() _bindings.Marshaler { |
| return _mwithAndWithoutRequestResponseNoRequestWithResponseResponse |
| } |
| |
| type withAndWithoutRequestResponseWithRequestNoResponseRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Arg string |
| } |
| |
| var _mwithAndWithoutRequestResponseWithRequestNoResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestNoResponseRequest{}) |
| |
| func (msg *withAndWithoutRequestResponseWithRequestNoResponseRequest) Marshaler() _bindings.Marshaler { |
| return _mwithAndWithoutRequestResponseWithRequestNoResponseRequest |
| } |
| |
| type withAndWithoutRequestResponseWithRequestEmptyResponseRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Arg string |
| } |
| |
| var _mwithAndWithoutRequestResponseWithRequestEmptyResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestEmptyResponseRequest{}) |
| |
| func (msg *withAndWithoutRequestResponseWithRequestEmptyResponseRequest) Marshaler() _bindings.Marshaler { |
| return _mwithAndWithoutRequestResponseWithRequestEmptyResponseRequest |
| } |
| |
| type withAndWithoutRequestResponseWithRequestWithResponseRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Arg string |
| } |
| |
| var _mwithAndWithoutRequestResponseWithRequestWithResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestWithResponseRequest{}) |
| |
| func (msg *withAndWithoutRequestResponseWithRequestWithResponseRequest) Marshaler() _bindings.Marshaler { |
| return _mwithAndWithoutRequestResponseWithRequestWithResponseRequest |
| } |
| |
| type withAndWithoutRequestResponseWithRequestWithResponseResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Ret string |
| } |
| |
| var _mwithAndWithoutRequestResponseWithRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithRequestWithResponseResponse{}) |
| |
| func (msg *withAndWithoutRequestResponseWithRequestWithResponseResponse) Marshaler() _bindings.Marshaler { |
| return _mwithAndWithoutRequestResponseWithRequestWithResponseResponse |
| } |
| |
| type withAndWithoutRequestResponseOnWithResponseResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| Ret string |
| } |
| |
| var _mwithAndWithoutRequestResponseOnWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseOnWithResponseResponse{}) |
| |
| func (msg *withAndWithoutRequestResponseOnWithResponseResponse) Marshaler() _bindings.Marshaler { |
| return _mwithAndWithoutRequestResponseOnWithResponseResponse |
| } |
| |
| type WithAndWithoutRequestResponseInterface _bindings.ChannelProxy |
| |
| |
| func (p *WithAndWithoutRequestResponseInterface) NoRequestNoResponse() error { |
| var req_ _bindings.Message |
| err := ((*_bindings.ChannelProxy)(p)).SendNew(WithAndWithoutRequestResponseNoRequestNoResponseOrdinal, req_) |
| return err |
| } |
| |
| func (p *WithAndWithoutRequestResponseInterface) NoRequestEmptyResponse() error { |
| var req_ _bindings.Message |
| var resp_ _bindings.Message |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal, req_, resp_) |
| return err |
| } |
| |
| func (p *WithAndWithoutRequestResponseInterface) NoRequestWithResponse() (string, error) { |
| var req_ _bindings.Message |
| resp_ := &withAndWithoutRequestResponseNoRequestWithResponseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(WithAndWithoutRequestResponseNoRequestWithResponseOrdinal, req_, resp_) |
| return resp_.Ret, err |
| } |
| |
| func (p *WithAndWithoutRequestResponseInterface) WithRequestNoResponse(arg string) error { |
| req_ := &withAndWithoutRequestResponseWithRequestNoResponseRequest{ |
| Arg: arg, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).SendNew(WithAndWithoutRequestResponseWithRequestNoResponseOrdinal, req_) |
| return err |
| } |
| |
| func (p *WithAndWithoutRequestResponseInterface) WithRequestEmptyResponse(arg string) error { |
| req_ := &withAndWithoutRequestResponseWithRequestEmptyResponseRequest{ |
| Arg: arg, |
| } |
| var resp_ _bindings.Message |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal, req_, resp_) |
| return err |
| } |
| |
| func (p *WithAndWithoutRequestResponseInterface) WithRequestWithResponse(arg string) (string, error) { |
| req_ := &withAndWithoutRequestResponseWithRequestWithResponseRequest{ |
| Arg: arg, |
| } |
| resp_ := &withAndWithoutRequestResponseWithRequestWithResponseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(WithAndWithoutRequestResponseWithRequestWithResponseOrdinal, req_, resp_) |
| return resp_.Ret, err |
| } |
| |
| func (p *WithAndWithoutRequestResponseInterface) ExpectOnEmptyResponse() error { |
| var resp_ _bindings.Message |
| err := ((*_bindings.ChannelProxy)(p)).RecvNew(WithAndWithoutRequestResponseOnEmptyResponseOrdinal, resp_) |
| return err |
| } |
| |
| func (p *WithAndWithoutRequestResponseInterface) ExpectOnWithResponse() (string, error) { |
| resp_ := &withAndWithoutRequestResponseOnWithResponseResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).RecvNew(WithAndWithoutRequestResponseOnWithResponseOrdinal, resp_) |
| return resp_.Ret, err |
| } |
| |
| |
| type WithAndWithoutRequestResponse interface { |
| NoRequestNoResponse() error |
| NoRequestEmptyResponse() error |
| NoRequestWithResponse() (string, error) |
| WithRequestNoResponse(arg string) error |
| WithRequestEmptyResponse(arg string) error |
| WithRequestWithResponse(arg string) (string, error) |
| } |
| |
| type WithAndWithoutRequestResponseTransitionalBase struct {} |
| |
| |
| type WithAndWithoutRequestResponseInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewWithAndWithoutRequestResponseInterfaceRequest() (WithAndWithoutRequestResponseInterfaceRequest, *WithAndWithoutRequestResponseInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return WithAndWithoutRequestResponseInterfaceRequest(req), (*WithAndWithoutRequestResponseInterface)(cli), err |
| } |
| |
| type WithAndWithoutRequestResponseStub struct { |
| Impl WithAndWithoutRequestResponse |
| } |
| |
| func (s *WithAndWithoutRequestResponseStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) { |
| switch ord { |
| case WithAndWithoutRequestResponseNoRequestNoResponseOrdinal: |
| err_ := s.Impl.NoRequestNoResponse() |
| return nil, err_ |
| case WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal: |
| err_ := s.Impl.NoRequestEmptyResponse() |
| return nil, err_ |
| case WithAndWithoutRequestResponseNoRequestWithResponseOrdinal: |
| ret, err_ := s.Impl.NoRequestWithResponse() |
| out_ := withAndWithoutRequestResponseNoRequestWithResponseResponse{} |
| out_.Ret = ret |
| return &out_, err_ |
| case WithAndWithoutRequestResponseWithRequestNoResponseOrdinal: |
| in_ := withAndWithoutRequestResponseWithRequestNoResponseRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.WithRequestNoResponse(in_.Arg) |
| return nil, err_ |
| case WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal: |
| in_ := withAndWithoutRequestResponseWithRequestEmptyResponseRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.WithRequestEmptyResponse(in_.Arg) |
| return nil, err_ |
| case WithAndWithoutRequestResponseWithRequestWithResponseOrdinal: |
| in_ := withAndWithoutRequestResponseWithRequestWithResponseRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| ret, err_ := s.Impl.WithRequestWithResponse(in_.Arg) |
| out_ := withAndWithoutRequestResponseWithRequestWithResponseResponse{} |
| out_.Ret = ret |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| type WithAndWithoutRequestResponseService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *WithAndWithoutRequestResponseService) Add(impl WithAndWithoutRequestResponse, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&WithAndWithoutRequestResponseStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *WithAndWithoutRequestResponseService) EventProxyFor(key _bindings.BindingKey) (*WithAndWithoutRequestResponseEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*WithAndWithoutRequestResponseEventProxy)(pxy), err |
| } |
| |
| type WithAndWithoutRequestResponseEventProxy _bindings.ChannelProxy |
| |
| func (p *WithAndWithoutRequestResponseEventProxy) OnEmptyResponse() error { |
| var event_ _bindings.Message |
| return ((*_bindings.ChannelProxy)(p)).SendNew(WithAndWithoutRequestResponseOnEmptyResponseOrdinal, event_) |
| } |
| func (p *WithAndWithoutRequestResponseEventProxy) OnWithResponse(ret string) error { |
| event_ := &withAndWithoutRequestResponseOnWithResponseResponse{ |
| Ret: ret, |
| } |
| return ((*_bindings.ChannelProxy)(p)).SendNew(WithAndWithoutRequestResponseOnWithResponseOrdinal, event_) |
| } |
| |
| |
| const ( |
| WithErrorSyntaxErrorAsPrimitiveOrdinal uint32 = 2069369145 |
| WithErrorSyntaxErrorAsPrimitiveGenOrdinal uint32 = 2069369145 |
| WithErrorSyntaxErrorAsEnumOrdinal uint32 = 1284890143 |
| WithErrorSyntaxErrorAsEnumGenOrdinal uint32 = 1284890143 |
| ) |
| |
| type withErrorSyntaxErrorAsPrimitiveResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Result WithErrorSyntaxErrorAsPrimitiveResult |
| } |
| |
| var _mwithErrorSyntaxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxErrorAsPrimitiveResponse{}) |
| |
| func (msg *withErrorSyntaxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler { |
| return _mwithErrorSyntaxErrorAsPrimitiveResponse |
| } |
| |
| type withErrorSyntaxErrorAsEnumResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Result WithErrorSyntaxErrorAsEnumResult |
| } |
| |
| var _mwithErrorSyntaxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxErrorAsEnumResponse{}) |
| |
| func (msg *withErrorSyntaxErrorAsEnumResponse) Marshaler() _bindings.Marshaler { |
| return _mwithErrorSyntaxErrorAsEnumResponse |
| } |
| |
| type WithErrorSyntaxInterface _bindings.ChannelProxy |
| |
| |
| func (p *WithErrorSyntaxInterface) ErrorAsPrimitive() (WithErrorSyntaxErrorAsPrimitiveResult, error) { |
| var req_ _bindings.Message |
| resp_ := &withErrorSyntaxErrorAsPrimitiveResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(WithErrorSyntaxErrorAsPrimitiveOrdinal, req_, resp_) |
| return resp_.Result, err |
| } |
| |
| func (p *WithErrorSyntaxInterface) ErrorAsEnum() (WithErrorSyntaxErrorAsEnumResult, error) { |
| var req_ _bindings.Message |
| resp_ := &withErrorSyntaxErrorAsEnumResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(WithErrorSyntaxErrorAsEnumOrdinal, req_, resp_) |
| return resp_.Result, err |
| } |
| |
| |
| type WithErrorSyntax interface { |
| ErrorAsPrimitive() (WithErrorSyntaxErrorAsPrimitiveResult, error) |
| ErrorAsEnum() (WithErrorSyntaxErrorAsEnumResult, error) |
| } |
| |
| type WithErrorSyntaxTransitionalBase struct {} |
| |
| |
| type WithErrorSyntaxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewWithErrorSyntaxInterfaceRequest() (WithErrorSyntaxInterfaceRequest, *WithErrorSyntaxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return WithErrorSyntaxInterfaceRequest(req), (*WithErrorSyntaxInterface)(cli), err |
| } |
| |
| type WithErrorSyntaxStub struct { |
| Impl WithErrorSyntax |
| } |
| |
| func (s *WithErrorSyntaxStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) { |
| switch ord { |
| case WithErrorSyntaxErrorAsPrimitiveOrdinal: |
| result, err_ := s.Impl.ErrorAsPrimitive() |
| out_ := withErrorSyntaxErrorAsPrimitiveResponse{} |
| out_.Result = result |
| return &out_, err_ |
| case WithErrorSyntaxErrorAsEnumOrdinal: |
| result, err_ := s.Impl.ErrorAsEnum() |
| out_ := withErrorSyntaxErrorAsEnumResponse{} |
| out_.Result = result |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| type WithErrorSyntaxService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *WithErrorSyntaxService) Add(impl WithErrorSyntax, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&WithErrorSyntaxStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *WithErrorSyntaxService) EventProxyFor(key _bindings.BindingKey) (*WithErrorSyntaxEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*WithErrorSyntaxEventProxy)(pxy), err |
| } |
| |
| type WithErrorSyntaxEventProxy _bindings.ChannelProxy |
| |
| |
| |
| const ( |
| OvernetInternalProtocolMethodAOrdinal uint32 = 1993818253 |
| OvernetInternalProtocolMethodAGenOrdinal uint32 = 1993818253 |
| OvernetInternalProtocolEventAOrdinal uint32 = 1746007436 |
| OvernetInternalProtocolEventAGenOrdinal uint32 = 1746007436 |
| OvernetInternalProtocolMethodBOrdinal uint32 = 952134976 |
| OvernetInternalProtocolMethodBGenOrdinal uint32 = 952134976 |
| OvernetInternalProtocolMutateSocketOrdinal uint32 = 1691201382 |
| OvernetInternalProtocolMutateSocketGenOrdinal uint32 = 1691201382 |
| ) |
| |
| type overnetInternalProtocolMethodARequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _movernetInternalProtocolMethodARequest = _bindings.CreateLazyMarshaler(overnetInternalProtocolMethodARequest{}) |
| |
| func (msg *overnetInternalProtocolMethodARequest) Marshaler() _bindings.Marshaler { |
| return _movernetInternalProtocolMethodARequest |
| } |
| |
| type overnetInternalProtocolEventAResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _movernetInternalProtocolEventAResponse = _bindings.CreateLazyMarshaler(overnetInternalProtocolEventAResponse{}) |
| |
| func (msg *overnetInternalProtocolEventAResponse) Marshaler() _bindings.Marshaler { |
| return _movernetInternalProtocolEventAResponse |
| } |
| |
| type overnetInternalProtocolMethodBRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _movernetInternalProtocolMethodBRequest = _bindings.CreateLazyMarshaler(overnetInternalProtocolMethodBRequest{}) |
| |
| func (msg *overnetInternalProtocolMethodBRequest) Marshaler() _bindings.Marshaler { |
| return _movernetInternalProtocolMethodBRequest |
| } |
| |
| type overnetInternalProtocolMethodBResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Result int64 |
| } |
| |
| var _movernetInternalProtocolMethodBResponse = _bindings.CreateLazyMarshaler(overnetInternalProtocolMethodBResponse{}) |
| |
| func (msg *overnetInternalProtocolMethodBResponse) Marshaler() _bindings.Marshaler { |
| return _movernetInternalProtocolMethodBResponse |
| } |
| |
| type overnetInternalProtocolMutateSocketRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| A _zx.Socket`fidl2:"0"` |
| } |
| |
| var _movernetInternalProtocolMutateSocketRequest = _bindings.CreateLazyMarshaler(overnetInternalProtocolMutateSocketRequest{}) |
| |
| func (msg *overnetInternalProtocolMutateSocketRequest) Marshaler() _bindings.Marshaler { |
| return _movernetInternalProtocolMutateSocketRequest |
| } |
| |
| type overnetInternalProtocolMutateSocketResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| B _zx.Socket`fidl2:"0"` |
| } |
| |
| var _movernetInternalProtocolMutateSocketResponse = _bindings.CreateLazyMarshaler(overnetInternalProtocolMutateSocketResponse{}) |
| |
| func (msg *overnetInternalProtocolMutateSocketResponse) Marshaler() _bindings.Marshaler { |
| return _movernetInternalProtocolMutateSocketResponse |
| } |
| |
| type OvernetInternalProtocolInterface _bindings.ChannelProxy |
| |
| |
| func (p *OvernetInternalProtocolInterface) MethodA(a int64,b int64) error { |
| req_ := &overnetInternalProtocolMethodARequest{ |
| A: a, |
| B: b, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).SendNew(OvernetInternalProtocolMethodAOrdinal, req_) |
| return err |
| } |
| |
| func (p *OvernetInternalProtocolInterface) ExpectEventA() (int64, int64, error) { |
| resp_ := &overnetInternalProtocolEventAResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).RecvNew(OvernetInternalProtocolEventAOrdinal, resp_) |
| return resp_.A, resp_.B, err |
| } |
| |
| func (p *OvernetInternalProtocolInterface) MethodB(a int64,b int64) (int64, error) { |
| req_ := &overnetInternalProtocolMethodBRequest{ |
| A: a, |
| B: b, |
| } |
| resp_ := &overnetInternalProtocolMethodBResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(OvernetInternalProtocolMethodBOrdinal, req_, resp_) |
| return resp_.Result, err |
| } |
| |
| func (p *OvernetInternalProtocolInterface) MutateSocket(a _zx.Socket) (_zx.Socket, error) { |
| req_ := &overnetInternalProtocolMutateSocketRequest{ |
| A: a, |
| } |
| resp_ := &overnetInternalProtocolMutateSocketResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(OvernetInternalProtocolMutateSocketOrdinal, req_, resp_) |
| return resp_.B, err |
| } |
| |
| |
| type OvernetInternalProtocol interface { |
| MethodA(a int64,b int64) error |
| MethodB(a int64,b int64) (int64, error) |
| MutateSocket(a _zx.Socket) (_zx.Socket, error) |
| } |
| |
| type OvernetInternalProtocolTransitionalBase struct {} |
| |
| |
| type OvernetInternalProtocolInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewOvernetInternalProtocolInterfaceRequest() (OvernetInternalProtocolInterfaceRequest, *OvernetInternalProtocolInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return OvernetInternalProtocolInterfaceRequest(req), (*OvernetInternalProtocolInterface)(cli), err |
| } |
| |
| type OvernetInternalProtocolStub struct { |
| Impl OvernetInternalProtocol |
| } |
| |
| func (s *OvernetInternalProtocolStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) { |
| switch ord { |
| case OvernetInternalProtocolMethodAOrdinal: |
| in_ := overnetInternalProtocolMethodARequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.MethodA(in_.A,in_.B) |
| return nil, err_ |
| case OvernetInternalProtocolMethodBOrdinal: |
| in_ := overnetInternalProtocolMethodBRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| result, err_ := s.Impl.MethodB(in_.A,in_.B) |
| out_ := overnetInternalProtocolMethodBResponse{} |
| out_.Result = result |
| return &out_, err_ |
| case OvernetInternalProtocolMutateSocketOrdinal: |
| in_ := overnetInternalProtocolMutateSocketRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| b, err_ := s.Impl.MutateSocket(in_.A) |
| out_ := overnetInternalProtocolMutateSocketResponse{} |
| out_.B = b |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| type OvernetInternalProtocolService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *OvernetInternalProtocolService) Add(impl OvernetInternalProtocol, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&OvernetInternalProtocolStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *OvernetInternalProtocolService) EventProxyFor(key _bindings.BindingKey) (*OvernetInternalProtocolEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*OvernetInternalProtocolEventProxy)(pxy), err |
| } |
| |
| type OvernetInternalProtocolEventProxy _bindings.ChannelProxy |
| |
| func (p *OvernetInternalProtocolEventProxy) EventA(a int64,b int64) error { |
| event_ := &overnetInternalProtocolEventAResponse{ |
| A: a, |
| B: b, |
| } |
| return ((*_bindings.ChannelProxy)(p)).SendNew(OvernetInternalProtocolEventAOrdinal, event_) |
| } |
| |
| |
| const ( |
| SocketControlProtocolMethodAOrdinal uint32 = 1007842318 |
| SocketControlProtocolMethodAGenOrdinal uint32 = 1007842318 |
| SocketControlProtocolEventAOrdinal uint32 = 955483393 |
| SocketControlProtocolEventAGenOrdinal uint32 = 955483393 |
| SocketControlProtocolMethodBOrdinal uint32 = 677342235 |
| SocketControlProtocolMethodBGenOrdinal uint32 = 677342235 |
| SocketControlProtocolMutateSocketOrdinal uint32 = 255772213 |
| SocketControlProtocolMutateSocketGenOrdinal uint32 = 255772213 |
| ) |
| |
| type socketControlProtocolMethodARequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _msocketControlProtocolMethodARequest = _bindings.CreateLazyMarshaler(socketControlProtocolMethodARequest{}) |
| |
| func (msg *socketControlProtocolMethodARequest) Marshaler() _bindings.Marshaler { |
| return _msocketControlProtocolMethodARequest |
| } |
| |
| type socketControlProtocolEventAResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _msocketControlProtocolEventAResponse = _bindings.CreateLazyMarshaler(socketControlProtocolEventAResponse{}) |
| |
| func (msg *socketControlProtocolEventAResponse) Marshaler() _bindings.Marshaler { |
| return _msocketControlProtocolEventAResponse |
| } |
| |
| type socketControlProtocolMethodBRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _msocketControlProtocolMethodBRequest = _bindings.CreateLazyMarshaler(socketControlProtocolMethodBRequest{}) |
| |
| func (msg *socketControlProtocolMethodBRequest) Marshaler() _bindings.Marshaler { |
| return _msocketControlProtocolMethodBRequest |
| } |
| |
| type socketControlProtocolMethodBResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Result int64 |
| } |
| |
| var _msocketControlProtocolMethodBResponse = _bindings.CreateLazyMarshaler(socketControlProtocolMethodBResponse{}) |
| |
| func (msg *socketControlProtocolMethodBResponse) Marshaler() _bindings.Marshaler { |
| return _msocketControlProtocolMethodBResponse |
| } |
| |
| type socketControlProtocolMutateSocketRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| A _zx.Socket`fidl2:"0"` |
| } |
| |
| var _msocketControlProtocolMutateSocketRequest = _bindings.CreateLazyMarshaler(socketControlProtocolMutateSocketRequest{}) |
| |
| func (msg *socketControlProtocolMutateSocketRequest) Marshaler() _bindings.Marshaler { |
| return _msocketControlProtocolMutateSocketRequest |
| } |
| |
| type socketControlProtocolMutateSocketResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| B _zx.Socket`fidl2:"0"` |
| } |
| |
| var _msocketControlProtocolMutateSocketResponse = _bindings.CreateLazyMarshaler(socketControlProtocolMutateSocketResponse{}) |
| |
| func (msg *socketControlProtocolMutateSocketResponse) Marshaler() _bindings.Marshaler { |
| return _msocketControlProtocolMutateSocketResponse |
| } |
| |
| type SocketControlProtocolInterface _bindings.SocketControlProxy |
| |
| |
| func (p *SocketControlProtocolInterface) MethodA(a int64,b int64) error { |
| req_ := &socketControlProtocolMethodARequest{ |
| A: a, |
| B: b, |
| } |
| err := ((*_bindings.SocketControlProxy)(p)).SendNew(SocketControlProtocolMethodAOrdinal, req_) |
| return err |
| } |
| |
| func (p *SocketControlProtocolInterface) ExpectEventA() (int64, int64, error) { |
| resp_ := &socketControlProtocolEventAResponse{} |
| err := ((*_bindings.SocketControlProxy)(p)).RecvNew(SocketControlProtocolEventAOrdinal, resp_) |
| return resp_.A, resp_.B, err |
| } |
| |
| func (p *SocketControlProtocolInterface) MethodB(a int64,b int64) (int64, error) { |
| req_ := &socketControlProtocolMethodBRequest{ |
| A: a, |
| B: b, |
| } |
| resp_ := &socketControlProtocolMethodBResponse{} |
| err := ((*_bindings.SocketControlProxy)(p)).CallNew(SocketControlProtocolMethodBOrdinal, req_, resp_) |
| return resp_.Result, err |
| } |
| |
| func (p *SocketControlProtocolInterface) MutateSocket(a _zx.Socket) (_zx.Socket, error) { |
| req_ := &socketControlProtocolMutateSocketRequest{ |
| A: a, |
| } |
| resp_ := &socketControlProtocolMutateSocketResponse{} |
| err := ((*_bindings.SocketControlProxy)(p)).CallNew(SocketControlProtocolMutateSocketOrdinal, req_, resp_) |
| return resp_.B, err |
| } |
| |
| |
| type SocketControlProtocol interface { |
| MethodA(a int64,b int64) error |
| MethodB(a int64,b int64) (int64, error) |
| MutateSocket(a _zx.Socket) (_zx.Socket, error) |
| } |
| |
| type SocketControlProtocolTransitionalBase struct {} |
| |
| |
| |
| type SocketControlProtocolStub struct { |
| Impl SocketControlProtocol |
| } |
| |
| func (s *SocketControlProtocolStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) { |
| switch ord { |
| case SocketControlProtocolMethodAOrdinal: |
| in_ := socketControlProtocolMethodARequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.MethodA(in_.A,in_.B) |
| return nil, err_ |
| case SocketControlProtocolMethodBOrdinal: |
| in_ := socketControlProtocolMethodBRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| result, err_ := s.Impl.MethodB(in_.A,in_.B) |
| out_ := socketControlProtocolMethodBResponse{} |
| out_.Result = result |
| return &out_, err_ |
| case SocketControlProtocolMutateSocketOrdinal: |
| in_ := socketControlProtocolMutateSocketRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| b, err_ := s.Impl.MutateSocket(in_.A) |
| out_ := socketControlProtocolMutateSocketResponse{} |
| out_.B = b |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| |
| type SocketControlProtocolEventProxy _bindings.SocketControlProxy |
| |
| func (p *SocketControlProtocolEventProxy) EventA(a int64,b int64) error { |
| event_ := &socketControlProtocolEventAResponse{ |
| A: a, |
| B: b, |
| } |
| return ((*_bindings.SocketControlProxy)(p)).SendNew(SocketControlProtocolEventAOrdinal, event_) |
| } |
| |
| |
| const ( |
| ChannelProtocolMethodAOrdinal uint32 = 1432785874 |
| ChannelProtocolMethodAGenOrdinal uint32 = 1432785874 |
| ChannelProtocolEventAOrdinal uint32 = 477676034 |
| ChannelProtocolEventAGenOrdinal uint32 = 477676034 |
| ChannelProtocolMethodBOrdinal uint32 = 180770075 |
| ChannelProtocolMethodBGenOrdinal uint32 = 180770075 |
| ChannelProtocolMutateSocketOrdinal uint32 = 1258480262 |
| ChannelProtocolMutateSocketGenOrdinal uint32 = 1258480262 |
| ) |
| |
| type channelProtocolMethodARequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _mchannelProtocolMethodARequest = _bindings.CreateLazyMarshaler(channelProtocolMethodARequest{}) |
| |
| func (msg *channelProtocolMethodARequest) Marshaler() _bindings.Marshaler { |
| return _mchannelProtocolMethodARequest |
| } |
| |
| type channelProtocolEventAResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _mchannelProtocolEventAResponse = _bindings.CreateLazyMarshaler(channelProtocolEventAResponse{}) |
| |
| func (msg *channelProtocolEventAResponse) Marshaler() _bindings.Marshaler { |
| return _mchannelProtocolEventAResponse |
| } |
| |
| type channelProtocolMethodBRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _mchannelProtocolMethodBRequest = _bindings.CreateLazyMarshaler(channelProtocolMethodBRequest{}) |
| |
| func (msg *channelProtocolMethodBRequest) Marshaler() _bindings.Marshaler { |
| return _mchannelProtocolMethodBRequest |
| } |
| |
| type channelProtocolMethodBResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Result int64 |
| } |
| |
| var _mchannelProtocolMethodBResponse = _bindings.CreateLazyMarshaler(channelProtocolMethodBResponse{}) |
| |
| func (msg *channelProtocolMethodBResponse) Marshaler() _bindings.Marshaler { |
| return _mchannelProtocolMethodBResponse |
| } |
| |
| type channelProtocolMutateSocketRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| A _zx.Socket`fidl2:"0"` |
| } |
| |
| var _mchannelProtocolMutateSocketRequest = _bindings.CreateLazyMarshaler(channelProtocolMutateSocketRequest{}) |
| |
| func (msg *channelProtocolMutateSocketRequest) Marshaler() _bindings.Marshaler { |
| return _mchannelProtocolMutateSocketRequest |
| } |
| |
| type channelProtocolMutateSocketResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| B _zx.Socket`fidl2:"0"` |
| } |
| |
| var _mchannelProtocolMutateSocketResponse = _bindings.CreateLazyMarshaler(channelProtocolMutateSocketResponse{}) |
| |
| func (msg *channelProtocolMutateSocketResponse) Marshaler() _bindings.Marshaler { |
| return _mchannelProtocolMutateSocketResponse |
| } |
| |
| type ChannelProtocolInterface _bindings.ChannelProxy |
| |
| |
| func (p *ChannelProtocolInterface) MethodA(a int64,b int64) error { |
| req_ := &channelProtocolMethodARequest{ |
| A: a, |
| B: b, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).SendNew(ChannelProtocolMethodAOrdinal, req_) |
| return err |
| } |
| |
| func (p *ChannelProtocolInterface) ExpectEventA() (int64, int64, error) { |
| resp_ := &channelProtocolEventAResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).RecvNew(ChannelProtocolEventAOrdinal, resp_) |
| return resp_.A, resp_.B, err |
| } |
| |
| func (p *ChannelProtocolInterface) MethodB(a int64,b int64) (int64, error) { |
| req_ := &channelProtocolMethodBRequest{ |
| A: a, |
| B: b, |
| } |
| resp_ := &channelProtocolMethodBResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(ChannelProtocolMethodBOrdinal, req_, resp_) |
| return resp_.Result, err |
| } |
| |
| func (p *ChannelProtocolInterface) MutateSocket(a _zx.Socket) (_zx.Socket, error) { |
| req_ := &channelProtocolMutateSocketRequest{ |
| A: a, |
| } |
| resp_ := &channelProtocolMutateSocketResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(ChannelProtocolMutateSocketOrdinal, req_, resp_) |
| return resp_.B, err |
| } |
| |
| |
| type ChannelProtocol interface { |
| MethodA(a int64,b int64) error |
| MethodB(a int64,b int64) (int64, error) |
| MutateSocket(a _zx.Socket) (_zx.Socket, error) |
| } |
| |
| type ChannelProtocolTransitionalBase struct {} |
| |
| |
| type ChannelProtocolInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewChannelProtocolInterfaceRequest() (ChannelProtocolInterfaceRequest, *ChannelProtocolInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return ChannelProtocolInterfaceRequest(req), (*ChannelProtocolInterface)(cli), err |
| } |
| |
| type ChannelProtocolStub struct { |
| Impl ChannelProtocol |
| } |
| |
| func (s *ChannelProtocolStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) { |
| switch ord { |
| case ChannelProtocolMethodAOrdinal: |
| in_ := channelProtocolMethodARequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.MethodA(in_.A,in_.B) |
| return nil, err_ |
| case ChannelProtocolMethodBOrdinal: |
| in_ := channelProtocolMethodBRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| result, err_ := s.Impl.MethodB(in_.A,in_.B) |
| out_ := channelProtocolMethodBResponse{} |
| out_.Result = result |
| return &out_, err_ |
| case ChannelProtocolMutateSocketOrdinal: |
| in_ := channelProtocolMutateSocketRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| b, err_ := s.Impl.MutateSocket(in_.A) |
| out_ := channelProtocolMutateSocketResponse{} |
| out_.B = b |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| type ChannelProtocolService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *ChannelProtocolService) Add(impl ChannelProtocol, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&ChannelProtocolStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *ChannelProtocolService) EventProxyFor(key _bindings.BindingKey) (*ChannelProtocolEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*ChannelProtocolEventProxy)(pxy), err |
| } |
| |
| type ChannelProtocolEventProxy _bindings.ChannelProxy |
| |
| func (p *ChannelProtocolEventProxy) EventA(a int64,b int64) error { |
| event_ := &channelProtocolEventAResponse{ |
| A: a, |
| B: b, |
| } |
| return ((*_bindings.ChannelProxy)(p)).SendNew(ChannelProtocolEventAOrdinal, event_) |
| } |
| |
| |
| const ( |
| KitchenSinkMethodAOrdinal uint32 = 450577456 |
| KitchenSinkMethodAGenOrdinal uint32 = 450577456 |
| KitchenSinkEventAOrdinal uint32 = 1795426833 |
| KitchenSinkEventAGenOrdinal uint32 = 1795426833 |
| KitchenSinkMethodBOrdinal uint32 = 1999489700 |
| KitchenSinkMethodBGenOrdinal uint32 = 1999489700 |
| KitchenSinkMutateSocketOrdinal uint32 = 115851270 |
| KitchenSinkMutateSocketGenOrdinal uint32 = 115851270 |
| ) |
| |
| type kitchenSinkMethodARequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _mkitchenSinkMethodARequest = _bindings.CreateLazyMarshaler(kitchenSinkMethodARequest{}) |
| |
| func (msg *kitchenSinkMethodARequest) Marshaler() _bindings.Marshaler { |
| return _mkitchenSinkMethodARequest |
| } |
| |
| type kitchenSinkEventAResponse struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _mkitchenSinkEventAResponse = _bindings.CreateLazyMarshaler(kitchenSinkEventAResponse{}) |
| |
| func (msg *kitchenSinkEventAResponse) Marshaler() _bindings.Marshaler { |
| return _mkitchenSinkEventAResponse |
| } |
| |
| type kitchenSinkMethodBRequest struct { |
| _ struct{} `fidl2:"s,16,0"` |
| A int64 |
| B int64 |
| } |
| |
| var _mkitchenSinkMethodBRequest = _bindings.CreateLazyMarshaler(kitchenSinkMethodBRequest{}) |
| |
| func (msg *kitchenSinkMethodBRequest) Marshaler() _bindings.Marshaler { |
| return _mkitchenSinkMethodBRequest |
| } |
| |
| type kitchenSinkMethodBResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| Result int64 |
| } |
| |
| var _mkitchenSinkMethodBResponse = _bindings.CreateLazyMarshaler(kitchenSinkMethodBResponse{}) |
| |
| func (msg *kitchenSinkMethodBResponse) Marshaler() _bindings.Marshaler { |
| return _mkitchenSinkMethodBResponse |
| } |
| |
| type kitchenSinkMutateSocketRequest struct { |
| _ struct{} `fidl2:"s,8,0"` |
| A _zx.Socket`fidl2:"0"` |
| } |
| |
| var _mkitchenSinkMutateSocketRequest = _bindings.CreateLazyMarshaler(kitchenSinkMutateSocketRequest{}) |
| |
| func (msg *kitchenSinkMutateSocketRequest) Marshaler() _bindings.Marshaler { |
| return _mkitchenSinkMutateSocketRequest |
| } |
| |
| type kitchenSinkMutateSocketResponse struct { |
| _ struct{} `fidl2:"s,8,0"` |
| B _zx.Socket`fidl2:"0"` |
| } |
| |
| var _mkitchenSinkMutateSocketResponse = _bindings.CreateLazyMarshaler(kitchenSinkMutateSocketResponse{}) |
| |
| func (msg *kitchenSinkMutateSocketResponse) Marshaler() _bindings.Marshaler { |
| return _mkitchenSinkMutateSocketResponse |
| } |
| |
| type KitchenSinkInterface _bindings.ChannelProxy |
| |
| |
| func (p *KitchenSinkInterface) MethodA(a int64,b int64) error { |
| req_ := &kitchenSinkMethodARequest{ |
| A: a, |
| B: b, |
| } |
| err := ((*_bindings.ChannelProxy)(p)).SendNew(KitchenSinkMethodAOrdinal, req_) |
| return err |
| } |
| |
| func (p *KitchenSinkInterface) ExpectEventA() (int64, int64, error) { |
| resp_ := &kitchenSinkEventAResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).RecvNew(KitchenSinkEventAOrdinal, resp_) |
| return resp_.A, resp_.B, err |
| } |
| |
| func (p *KitchenSinkInterface) MethodB(a int64,b int64) (int64, error) { |
| req_ := &kitchenSinkMethodBRequest{ |
| A: a, |
| B: b, |
| } |
| resp_ := &kitchenSinkMethodBResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(KitchenSinkMethodBOrdinal, req_, resp_) |
| return resp_.Result, err |
| } |
| |
| func (p *KitchenSinkInterface) MutateSocket(a _zx.Socket) (_zx.Socket, error) { |
| req_ := &kitchenSinkMutateSocketRequest{ |
| A: a, |
| } |
| resp_ := &kitchenSinkMutateSocketResponse{} |
| err := ((*_bindings.ChannelProxy)(p)).CallNew(KitchenSinkMutateSocketOrdinal, req_, resp_) |
| return resp_.B, err |
| } |
| |
| |
| type KitchenSink interface { |
| MethodA(a int64,b int64) error |
| MethodB(a int64,b int64) (int64, error) |
| MutateSocket(a _zx.Socket) (_zx.Socket, error) |
| } |
| |
| type KitchenSinkTransitionalBase struct {} |
| |
| |
| type KitchenSinkInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewKitchenSinkInterfaceRequest() (KitchenSinkInterfaceRequest, *KitchenSinkInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return KitchenSinkInterfaceRequest(req), (*KitchenSinkInterface)(cli), err |
| } |
| |
| type KitchenSinkStub struct { |
| Impl KitchenSink |
| } |
| |
| func (s *KitchenSinkStub) DispatchNew(ord uint32, b_ []byte, h_ []_zx.Handle) (_bindings.Message, error) { |
| switch ord { |
| case KitchenSinkMethodAOrdinal: |
| in_ := kitchenSinkMethodARequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| err_ := s.Impl.MethodA(in_.A,in_.B) |
| return nil, err_ |
| case KitchenSinkMethodBOrdinal: |
| in_ := kitchenSinkMethodBRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| result, err_ := s.Impl.MethodB(in_.A,in_.B) |
| out_ := kitchenSinkMethodBResponse{} |
| out_.Result = result |
| return &out_, err_ |
| case KitchenSinkMutateSocketOrdinal: |
| in_ := kitchenSinkMutateSocketRequest{} |
| if _, _, err_ := _bindings.UnmarshalNew(b_, h_, &in_); err_ != nil { |
| return nil, err_ |
| } |
| b, err_ := s.Impl.MutateSocket(in_.A) |
| out_ := kitchenSinkMutateSocketResponse{} |
| out_.B = b |
| return &out_, err_ |
| } |
| return nil, _bindings.ErrUnknownOrdinal |
| } |
| type KitchenSinkService struct { |
| _bindings.BindingSet |
| } |
| |
| func (s *KitchenSinkService) Add(impl KitchenSink, c _zx.Channel, onError func(error)) (_bindings.BindingKey, error) { |
| return s.BindingSet.Add(&KitchenSinkStub{Impl: impl}, c, onError) |
| } |
| |
| func (s *KitchenSinkService) EventProxyFor(key _bindings.BindingKey) (*KitchenSinkEventProxy, bool) { |
| pxy, err := s.BindingSet.ProxyFor(key) |
| return (*KitchenSinkEventProxy)(pxy), err |
| } |
| |
| type KitchenSinkEventProxy _bindings.ChannelProxy |
| |
| func (p *KitchenSinkEventProxy) EventA(a int64,b int64) error { |
| event_ := &kitchenSinkEventAResponse{ |
| A: a, |
| B: b, |
| } |
| return ((*_bindings.ChannelProxy)(p)).SendNew(KitchenSinkEventAOrdinal, event_) |
| } |
| |
| |
