blob: f4903375f6fd4650d371114b0cbeb4424a757478 [file] [log] [blame]
// Code generated by fidlgen; DO NOT EDIT.
package protocols
import (
_zx "syscall/zx"
_bindings "syscall/zx/fidl"
)
var _ _bindings.Enum = ObjType(0)
type ObjType uint32
const (
ObjTypeNone ObjType = 0
ObjTypeSocket ObjType = 14
)
func (_ ObjType) I_EnumValues() []ObjType {
return []ObjType{
ObjTypeNone,
ObjTypeSocket,
}
}
func (_ ObjType) I_EnumIsStrict() bool {
return true
}
func (x ObjType) IsUnknown() bool {
switch x {
case 0:
return true
case 14:
return true
default:
return false
}
}
func (x ObjType) String() string {
switch x {
case 0:
return "None"
case 14:
return "Socket"
}
return "Unknown"
}
var _ _bindings.Enum = ErrorEnum(0)
type ErrorEnum uint32
const (
ErrorEnumErrFoo ErrorEnum = 1
ErrorEnumErrBar ErrorEnum = 2
)
func (_ ErrorEnum) I_EnumValues() []ErrorEnum {
return []ErrorEnum{
ErrorEnumErrFoo,
ErrorEnumErrBar,
}
}
func (_ ErrorEnum) I_EnumIsStrict() bool {
return true
}
func (x ErrorEnum) IsUnknown() bool {
switch x {
case 1:
return true
case 2:
return true
default:
return false
}
}
func (x ErrorEnum) String() string {
switch x {
case 1:
return "ErrFoo"
case 2:
return "ErrBar"
}
return "Unknown"
}
var _ _bindings.Bits = Rights(0)
type Rights uint32
const (
RightsTransfer Rights = 1
RightsDuplicate Rights = 2
Rights_Mask Rights = 3
)
func (_ Rights) I_BitsMask() Rights {
return Rights_Mask
}
func (_ Rights) I_BitsIsStrict() bool {
return true
}
func (x Rights) HasUnknownBits() bool {
return x.GetUnknownBits() != 0
}
func (x Rights) GetUnknownBits() uint64 {
return uint64(^Rights_Mask & x)
}
func (x Rights) InvertBits() Rights {
return Rights_Mask & ^x
}
// HasBits validates that all flipped bits in the mask are set.
func (x Rights) HasBits(mask Rights) bool {
return mask|x == x
}
// ClearBits ensures all flipped bits in the mask are unset.
func (x Rights) ClearBits(mask Rights) Rights {
return ^mask & x
}
func (x Rights) String() string {
switch x {
case 1:
return "Transfer"
case 2:
return "Duplicate"
}
return "Unknown"
}
type WithErrorSyntaxResponseAsStructResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"24" fidl_alignment_v2:"8"`
A int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
B int64 `fidl_offset_v1:"8" fidl_offset_v2:"8"`
C int64 `fidl_offset_v1:"16" fidl_offset_v2:"16"`
}
var _mWithErrorSyntaxResponseAsStructResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxResponseAsStructResponse{})
func (msg *WithErrorSyntaxResponseAsStructResponse) Marshaler() _bindings.Marshaler {
return _mWithErrorSyntaxResponseAsStructResponse
}
type WithErrorSyntaxErrorAsPrimitiveResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mWithErrorSyntaxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsPrimitiveResponse{})
func (msg *WithErrorSyntaxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler {
return _mWithErrorSyntaxErrorAsPrimitiveResponse
}
type WithErrorSyntaxErrorAsEnumResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"1" fidl_alignment_v1:"1" fidl_size_v2:"1" fidl_alignment_v2:"1"`
}
var _mWithErrorSyntaxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxErrorAsEnumResponse{})
func (msg *WithErrorSyntaxErrorAsEnumResponse) Marshaler() _bindings.Marshaler {
return _mWithErrorSyntaxErrorAsEnumResponse
}
type WithErrorSyntaxHandleInResultResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4" fidl_size_v2:"4" fidl_alignment_v2:"4"`
H _zx.Handle `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mWithErrorSyntaxHandleInResultResponse = _bindings.CreateLazyMarshaler(WithErrorSyntaxHandleInResultResponse{})
func (msg *WithErrorSyntaxHandleInResultResponse) Marshaler() _bindings.Marshaler {
return _mWithErrorSyntaxHandleInResultResponse
}
type ProtocolEnds struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"4" fidl_size_v2:"16" fidl_alignment_v2:"4"`
Client DiscoverableProtocolWithCtxInterface `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4"`
Server DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v1:"4" fidl_offset_v2:"4" fidl_handle_subtype:"4" fidl_bounds:"0"`
ClientOpt DiscoverableProtocolWithCtxInterface `fidl_offset_v1:"8" fidl_offset_v2:"8" fidl_handle_subtype:"4"`
ServerOpt DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v1:"12" fidl_offset_v2:"12" fidl_handle_subtype:"4" fidl_bounds:"1"`
}
var _mProtocolEnds = _bindings.CreateLazyMarshaler(ProtocolEnds{})
func (msg *ProtocolEnds) Marshaler() _bindings.Marshaler {
return _mProtocolEnds
}
type withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Ret string `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:""`
}
var _mwithAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{})
func (msg *withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
return _mwithAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse
}
type withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Arg string `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:""`
}
var _mwithAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{})
func (msg *withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest) Marshaler() _bindings.Marshaler {
return _mwithAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest
}
type withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Arg string `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:""`
}
var _mwithAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest{})
func (msg *withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest) Marshaler() _bindings.Marshaler {
return _mwithAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest
}
type withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Arg string `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:""`
}
var _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest{})
func (msg *withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest) Marshaler() _bindings.Marshaler {
return _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest
}
type withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Ret string `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:""`
}
var _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{})
func (msg *withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse) Marshaler() _bindings.Marshaler {
return _mwithAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse
}
type withAndWithoutRequestResponseWithCtxOnWithResponseResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Ret string `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_bounds:""`
}
var _mwithAndWithoutRequestResponseWithCtxOnWithResponseResponse = _bindings.CreateLazyMarshaler(withAndWithoutRequestResponseWithCtxOnWithResponseResponse{})
func (msg *withAndWithoutRequestResponseWithCtxOnWithResponseResponse) Marshaler() _bindings.Marshaler {
return _mwithAndWithoutRequestResponseWithCtxOnWithResponseResponse
}
type withErrorSyntaxWithCtxResponseAsStructResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result WithErrorSyntaxResponseAsStructResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mwithErrorSyntaxWithCtxResponseAsStructResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxResponseAsStructResponse{})
func (msg *withErrorSyntaxWithCtxResponseAsStructResponse) Marshaler() _bindings.Marshaler {
return _mwithErrorSyntaxWithCtxResponseAsStructResponse
}
type withErrorSyntaxWithCtxErrorAsPrimitiveResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result WithErrorSyntaxErrorAsPrimitiveResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mwithErrorSyntaxWithCtxErrorAsPrimitiveResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxErrorAsPrimitiveResponse{})
func (msg *withErrorSyntaxWithCtxErrorAsPrimitiveResponse) Marshaler() _bindings.Marshaler {
return _mwithErrorSyntaxWithCtxErrorAsPrimitiveResponse
}
type withErrorSyntaxWithCtxErrorAsEnumResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result WithErrorSyntaxErrorAsEnumResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mwithErrorSyntaxWithCtxErrorAsEnumResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxErrorAsEnumResponse{})
func (msg *withErrorSyntaxWithCtxErrorAsEnumResponse) Marshaler() _bindings.Marshaler {
return _mwithErrorSyntaxWithCtxErrorAsEnumResponse
}
type withErrorSyntaxWithCtxHandleInResultResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Result WithErrorSyntaxHandleInResultResult `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mwithErrorSyntaxWithCtxHandleInResultResponse = _bindings.CreateLazyMarshaler(withErrorSyntaxWithCtxHandleInResultResponse{})
func (msg *withErrorSyntaxWithCtxHandleInResultResponse) Marshaler() _bindings.Marshaler {
return _mwithErrorSyntaxWithCtxHandleInResultResponse
}
type channelProtocolWithCtxMethodARequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
A int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
B int64 `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}
var _mchannelProtocolWithCtxMethodARequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodARequest{})
func (msg *channelProtocolWithCtxMethodARequest) Marshaler() _bindings.Marshaler {
return _mchannelProtocolWithCtxMethodARequest
}
type channelProtocolWithCtxEventAResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
A int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
B int64 `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}
var _mchannelProtocolWithCtxEventAResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxEventAResponse{})
func (msg *channelProtocolWithCtxEventAResponse) Marshaler() _bindings.Marshaler {
return _mchannelProtocolWithCtxEventAResponse
}
type channelProtocolWithCtxMethodBRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
A int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
B int64 `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}
var _mchannelProtocolWithCtxMethodBRequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodBRequest{})
func (msg *channelProtocolWithCtxMethodBRequest) Marshaler() _bindings.Marshaler {
return _mchannelProtocolWithCtxMethodBRequest
}
type channelProtocolWithCtxMethodBResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Result int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mchannelProtocolWithCtxMethodBResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMethodBResponse{})
func (msg *channelProtocolWithCtxMethodBResponse) Marshaler() _bindings.Marshaler {
return _mchannelProtocolWithCtxMethodBResponse
}
type channelProtocolWithCtxTakeHandleRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
H _zx.Handle `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"0" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mchannelProtocolWithCtxTakeHandleRequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxTakeHandleRequest{})
func (msg *channelProtocolWithCtxTakeHandleRequest) Marshaler() _bindings.Marshaler {
return _mchannelProtocolWithCtxTakeHandleRequest
}
type channelProtocolWithCtxMutateSocketRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
A _zx.Socket `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mchannelProtocolWithCtxMutateSocketRequest = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMutateSocketRequest{})
func (msg *channelProtocolWithCtxMutateSocketRequest) Marshaler() _bindings.Marshaler {
return _mchannelProtocolWithCtxMutateSocketRequest
}
type channelProtocolWithCtxMutateSocketResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
B _zx.Socket `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"2147483648" fidl_bounds:"0"`
}
var _mchannelProtocolWithCtxMutateSocketResponse = _bindings.CreateLazyMarshaler(channelProtocolWithCtxMutateSocketResponse{})
func (msg *channelProtocolWithCtxMutateSocketResponse) Marshaler() _bindings.Marshaler {
return _mchannelProtocolWithCtxMutateSocketResponse
}
type syscallProtocolWithCtxMethodCRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
A int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
B int64 `fidl_offset_v1:"8" fidl_offset_v2:"8"`
}
var _msyscallProtocolWithCtxMethodCRequest = _bindings.CreateLazyMarshaler(syscallProtocolWithCtxMethodCRequest{})
func (msg *syscallProtocolWithCtxMethodCRequest) Marshaler() _bindings.Marshaler {
return _msyscallProtocolWithCtxMethodCRequest
}
type transitionalWithCtxRequestRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
X int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mtransitionalWithCtxRequestRequest = _bindings.CreateLazyMarshaler(transitionalWithCtxRequestRequest{})
func (msg *transitionalWithCtxRequestRequest) Marshaler() _bindings.Marshaler {
return _mtransitionalWithCtxRequestRequest
}
type transitionalWithCtxRequestResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Y int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mtransitionalWithCtxRequestResponse = _bindings.CreateLazyMarshaler(transitionalWithCtxRequestResponse{})
func (msg *transitionalWithCtxRequestResponse) Marshaler() _bindings.Marshaler {
return _mtransitionalWithCtxRequestResponse
}
type transitionalWithCtxOneWayRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
X int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mtransitionalWithCtxOneWayRequest = _bindings.CreateLazyMarshaler(transitionalWithCtxOneWayRequest{})
func (msg *transitionalWithCtxOneWayRequest) Marshaler() _bindings.Marshaler {
return _mtransitionalWithCtxOneWayRequest
}
type transitionalWithCtxEventResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
X int64 `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mtransitionalWithCtxEventResponse = _bindings.CreateLazyMarshaler(transitionalWithCtxEventResponse{})
func (msg *transitionalWithCtxEventResponse) Marshaler() _bindings.Marshaler {
return _mtransitionalWithCtxEventResponse
}
type handleRightsProtocolWithCtxNoResponseMethodRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
H _zx.Socket `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"3" fidl_bounds:"0"`
}
var _mhandleRightsProtocolWithCtxNoResponseMethodRequest = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxNoResponseMethodRequest{})
func (msg *handleRightsProtocolWithCtxNoResponseMethodRequest) Marshaler() _bindings.Marshaler {
return _mhandleRightsProtocolWithCtxNoResponseMethodRequest
}
type handleRightsProtocolWithCtxResponseMethodRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
H _zx.Socket `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"3" fidl_bounds:"0"`
}
var _mhandleRightsProtocolWithCtxResponseMethodRequest = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxResponseMethodRequest{})
func (msg *handleRightsProtocolWithCtxResponseMethodRequest) Marshaler() _bindings.Marshaler {
return _mhandleRightsProtocolWithCtxResponseMethodRequest
}
type handleRightsProtocolWithCtxResponseMethodResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
H _zx.Socket `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"1" fidl_bounds:"0"`
}
var _mhandleRightsProtocolWithCtxResponseMethodResponse = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxResponseMethodResponse{})
func (msg *handleRightsProtocolWithCtxResponseMethodResponse) Marshaler() _bindings.Marshaler {
return _mhandleRightsProtocolWithCtxResponseMethodResponse
}
type handleRightsProtocolWithCtxAnEventResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
H _zx.Socket `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"14" fidl_handle_rights:"3" fidl_bounds:"0"`
}
var _mhandleRightsProtocolWithCtxAnEventResponse = _bindings.CreateLazyMarshaler(handleRightsProtocolWithCtxAnEventResponse{})
func (msg *handleRightsProtocolWithCtxAnEventResponse) Marshaler() _bindings.Marshaler {
return _mhandleRightsProtocolWithCtxAnEventResponse
}
type withProtocolEndsWithCtxClientEndsRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
In DiscoverableProtocolWithCtxInterface `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4"`
}
var _mwithProtocolEndsWithCtxClientEndsRequest = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxClientEndsRequest{})
func (msg *withProtocolEndsWithCtxClientEndsRequest) Marshaler() _bindings.Marshaler {
return _mwithProtocolEndsWithCtxClientEndsRequest
}
type withProtocolEndsWithCtxClientEndsResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Out DiscoverableProtocolWithCtxInterface `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4"`
}
var _mwithProtocolEndsWithCtxClientEndsResponse = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxClientEndsResponse{})
func (msg *withProtocolEndsWithCtxClientEndsResponse) Marshaler() _bindings.Marshaler {
return _mwithProtocolEndsWithCtxClientEndsResponse
}
type withProtocolEndsWithCtxServerEndsRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
In DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4" fidl_bounds:"1"`
}
var _mwithProtocolEndsWithCtxServerEndsRequest = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxServerEndsRequest{})
func (msg *withProtocolEndsWithCtxServerEndsRequest) Marshaler() _bindings.Marshaler {
return _mwithProtocolEndsWithCtxServerEndsRequest
}
type withProtocolEndsWithCtxServerEndsResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"8" fidl_alignment_v1:"8" fidl_size_v2:"8" fidl_alignment_v2:"8"`
Out DiscoverableProtocolWithCtxInterfaceRequest `fidl_offset_v1:"0" fidl_offset_v2:"0" fidl_handle_subtype:"4" fidl_bounds:"0"`
}
var _mwithProtocolEndsWithCtxServerEndsResponse = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxServerEndsResponse{})
func (msg *withProtocolEndsWithCtxServerEndsResponse) Marshaler() _bindings.Marshaler {
return _mwithProtocolEndsWithCtxServerEndsResponse
}
type withProtocolEndsWithCtxStructContainingEndsRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
In ProtocolEnds `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mwithProtocolEndsWithCtxStructContainingEndsRequest = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxStructContainingEndsRequest{})
func (msg *withProtocolEndsWithCtxStructContainingEndsRequest) Marshaler() _bindings.Marshaler {
return _mwithProtocolEndsWithCtxStructContainingEndsRequest
}
type withProtocolEndsWithCtxStructContainingEndsResponse struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
Out ProtocolEnds `fidl_offset_v1:"0" fidl_offset_v2:"0"`
}
var _mwithProtocolEndsWithCtxStructContainingEndsResponse = _bindings.CreateLazyMarshaler(withProtocolEndsWithCtxStructContainingEndsResponse{})
func (msg *withProtocolEndsWithCtxStructContainingEndsResponse) Marshaler() _bindings.Marshaler {
return _mwithProtocolEndsWithCtxStructContainingEndsResponse
}
type manyParametersWithCtxFifteenRequest struct {
_ struct{} `fidl:"s" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8"`
P1 bool `fidl_offset_v1:"0" fidl_offset_v2:"0"`
P2 bool `fidl_offset_v1:"1" fidl_offset_v2:"1"`
P3 bool `fidl_offset_v1:"2" fidl_offset_v2:"2"`
P4 bool `fidl_offset_v1:"3" fidl_offset_v2:"3"`
P5 bool `fidl_offset_v1:"4" fidl_offset_v2:"4"`
P6 bool `fidl_offset_v1:"5" fidl_offset_v2:"5"`
P7 bool `fidl_offset_v1:"6" fidl_offset_v2:"6"`
P8 bool `fidl_offset_v1:"7" fidl_offset_v2:"7"`
P9 bool `fidl_offset_v1:"8" fidl_offset_v2:"8"`
P10 bool `fidl_offset_v1:"9" fidl_offset_v2:"9"`
P11 bool `fidl_offset_v1:"10" fidl_offset_v2:"10"`
P12 bool `fidl_offset_v1:"11" fidl_offset_v2:"11"`
P13 bool `fidl_offset_v1:"12" fidl_offset_v2:"12"`
P14 bool `fidl_offset_v1:"13" fidl_offset_v2:"13"`
P15 bool `fidl_offset_v1:"14" fidl_offset_v2:"14"`
}
var _mmanyParametersWithCtxFifteenRequest = _bindings.CreateLazyMarshaler(manyParametersWithCtxFifteenRequest{})
func (msg *manyParametersWithCtxFifteenRequest) Marshaler() _bindings.Marshaler {
return _mmanyParametersWithCtxFifteenRequest
}
type I_withErrorSyntaxResponseAsStructResultTag uint64
const (
WithErrorSyntaxResponseAsStructResultResponse = 1 // 0x00000001
WithErrorSyntaxResponseAsStructResultErr = 2 // 0x00000002
)
type WithErrorSyntaxResponseAsStructResult struct {
I_withErrorSyntaxResponseAsStructResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
Response WithErrorSyntaxResponseAsStructResponse `fidl_ordinal:"1"`
Err uint32 `fidl_ordinal:"2"`
}
func (_m *WithErrorSyntaxResponseAsStructResult) reset() {
switch _m.I_withErrorSyntaxResponseAsStructResultTag {
case 1:
var _zeroed WithErrorSyntaxResponseAsStructResponse
_m.Response = _zeroed
case 2:
var _zeroed uint32
_m.Err = _zeroed
}
}
func (_m *WithErrorSyntaxResponseAsStructResult) Which() I_withErrorSyntaxResponseAsStructResultTag {
return _m.I_withErrorSyntaxResponseAsStructResultTag
}
func (_m *WithErrorSyntaxResponseAsStructResult) Ordinal() uint64 {
return uint64(_m.I_withErrorSyntaxResponseAsStructResultTag)
}
func (_m *WithErrorSyntaxResponseAsStructResult) SetResponse(response WithErrorSyntaxResponseAsStructResponse) {
_m.reset()
_m.I_withErrorSyntaxResponseAsStructResultTag = WithErrorSyntaxResponseAsStructResultResponse
_m.Response = response
}
func WithErrorSyntaxResponseAsStructResultWithResponse(response WithErrorSyntaxResponseAsStructResponse) WithErrorSyntaxResponseAsStructResult {
var _u WithErrorSyntaxResponseAsStructResult
_u.SetResponse(response)
return _u
}
func (_m *WithErrorSyntaxResponseAsStructResult) SetErr(err uint32) {
_m.reset()
_m.I_withErrorSyntaxResponseAsStructResultTag = WithErrorSyntaxResponseAsStructResultErr
_m.Err = err
}
func WithErrorSyntaxResponseAsStructResultWithErr(err uint32) WithErrorSyntaxResponseAsStructResult {
var _u WithErrorSyntaxResponseAsStructResult
_u.SetErr(err)
return _u
}
type I_withErrorSyntaxErrorAsPrimitiveResultTag uint64
const (
WithErrorSyntaxErrorAsPrimitiveResultResponse = 1 // 0x00000001
WithErrorSyntaxErrorAsPrimitiveResultErr = 2 // 0x00000002
)
type WithErrorSyntaxErrorAsPrimitiveResult struct {
I_withErrorSyntaxErrorAsPrimitiveResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
Response WithErrorSyntaxErrorAsPrimitiveResponse `fidl_ordinal:"1"`
Err uint32 `fidl_ordinal:"2"`
}
func (_m *WithErrorSyntaxErrorAsPrimitiveResult) reset() {
switch _m.I_withErrorSyntaxErrorAsPrimitiveResultTag {
case 1:
var _zeroed WithErrorSyntaxErrorAsPrimitiveResponse
_m.Response = _zeroed
case 2:
var _zeroed uint32
_m.Err = _zeroed
}
}
func (_m *WithErrorSyntaxErrorAsPrimitiveResult) Which() I_withErrorSyntaxErrorAsPrimitiveResultTag {
return _m.I_withErrorSyntaxErrorAsPrimitiveResultTag
}
func (_m *WithErrorSyntaxErrorAsPrimitiveResult) Ordinal() uint64 {
return uint64(_m.I_withErrorSyntaxErrorAsPrimitiveResultTag)
}
func (_m *WithErrorSyntaxErrorAsPrimitiveResult) SetResponse(response WithErrorSyntaxErrorAsPrimitiveResponse) {
_m.reset()
_m.I_withErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultResponse
_m.Response = response
}
func WithErrorSyntaxErrorAsPrimitiveResultWithResponse(response WithErrorSyntaxErrorAsPrimitiveResponse) WithErrorSyntaxErrorAsPrimitiveResult {
var _u WithErrorSyntaxErrorAsPrimitiveResult
_u.SetResponse(response)
return _u
}
func (_m *WithErrorSyntaxErrorAsPrimitiveResult) SetErr(err uint32) {
_m.reset()
_m.I_withErrorSyntaxErrorAsPrimitiveResultTag = WithErrorSyntaxErrorAsPrimitiveResultErr
_m.Err = err
}
func WithErrorSyntaxErrorAsPrimitiveResultWithErr(err uint32) WithErrorSyntaxErrorAsPrimitiveResult {
var _u WithErrorSyntaxErrorAsPrimitiveResult
_u.SetErr(err)
return _u
}
type I_withErrorSyntaxErrorAsEnumResultTag uint64
const (
WithErrorSyntaxErrorAsEnumResultResponse = 1 // 0x00000001
WithErrorSyntaxErrorAsEnumResultErr = 2 // 0x00000002
)
type WithErrorSyntaxErrorAsEnumResult struct {
I_withErrorSyntaxErrorAsEnumResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"false"`
Response WithErrorSyntaxErrorAsEnumResponse `fidl_ordinal:"1"`
Err ErrorEnum `fidl_ordinal:"2"`
}
func (_m *WithErrorSyntaxErrorAsEnumResult) reset() {
switch _m.I_withErrorSyntaxErrorAsEnumResultTag {
case 1:
var _zeroed WithErrorSyntaxErrorAsEnumResponse
_m.Response = _zeroed
case 2:
var _zeroed ErrorEnum
_m.Err = _zeroed
}
}
func (_m *WithErrorSyntaxErrorAsEnumResult) Which() I_withErrorSyntaxErrorAsEnumResultTag {
return _m.I_withErrorSyntaxErrorAsEnumResultTag
}
func (_m *WithErrorSyntaxErrorAsEnumResult) Ordinal() uint64 {
return uint64(_m.I_withErrorSyntaxErrorAsEnumResultTag)
}
func (_m *WithErrorSyntaxErrorAsEnumResult) SetResponse(response WithErrorSyntaxErrorAsEnumResponse) {
_m.reset()
_m.I_withErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultResponse
_m.Response = response
}
func WithErrorSyntaxErrorAsEnumResultWithResponse(response WithErrorSyntaxErrorAsEnumResponse) WithErrorSyntaxErrorAsEnumResult {
var _u WithErrorSyntaxErrorAsEnumResult
_u.SetResponse(response)
return _u
}
func (_m *WithErrorSyntaxErrorAsEnumResult) SetErr(err ErrorEnum) {
_m.reset()
_m.I_withErrorSyntaxErrorAsEnumResultTag = WithErrorSyntaxErrorAsEnumResultErr
_m.Err = err
}
func WithErrorSyntaxErrorAsEnumResultWithErr(err ErrorEnum) WithErrorSyntaxErrorAsEnumResult {
var _u WithErrorSyntaxErrorAsEnumResult
_u.SetErr(err)
return _u
}
type I_withErrorSyntaxHandleInResultResultTag uint64
const (
WithErrorSyntaxHandleInResultResultResponse = 1 // 0x00000001
WithErrorSyntaxHandleInResultResultErr = 2 // 0x00000002
)
type WithErrorSyntaxHandleInResultResult struct {
I_withErrorSyntaxHandleInResultResultTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_size_v2:"16" fidl_alignment_v2:"8" fidl_resource:"true"`
Response WithErrorSyntaxHandleInResultResponse `fidl_ordinal:"1"`
Err uint32 `fidl_ordinal:"2"`
}
func (_m *WithErrorSyntaxHandleInResultResult) reset() {
switch _m.I_withErrorSyntaxHandleInResultResultTag {
case 1:
var _zeroed WithErrorSyntaxHandleInResultResponse
_m.Response = _zeroed
case 2:
var _zeroed uint32
_m.Err = _zeroed
}
}
func (_m *WithErrorSyntaxHandleInResultResult) Which() I_withErrorSyntaxHandleInResultResultTag {
return _m.I_withErrorSyntaxHandleInResultResultTag
}
func (_m *WithErrorSyntaxHandleInResultResult) Ordinal() uint64 {
return uint64(_m.I_withErrorSyntaxHandleInResultResultTag)
}
func (_m *WithErrorSyntaxHandleInResultResult) SetResponse(response WithErrorSyntaxHandleInResultResponse) {
_m.reset()
_m.I_withErrorSyntaxHandleInResultResultTag = WithErrorSyntaxHandleInResultResultResponse
_m.Response = response
}
func WithErrorSyntaxHandleInResultResultWithResponse(response WithErrorSyntaxHandleInResultResponse) WithErrorSyntaxHandleInResultResult {
var _u WithErrorSyntaxHandleInResultResult
_u.SetResponse(response)
return _u
}
func (_m *WithErrorSyntaxHandleInResultResult) SetErr(err uint32) {
_m.reset()
_m.I_withErrorSyntaxHandleInResultResultTag = WithErrorSyntaxHandleInResultResultErr
_m.Err = err
}
func WithErrorSyntaxHandleInResultResultWithErr(err uint32) WithErrorSyntaxHandleInResultResult {
var _u WithErrorSyntaxHandleInResultResult
_u.SetErr(err)
return _u
}
const (
WithAndWithoutRequestResponseNoRequestNoResponseOrdinal uint64 = 0x6ad894147d0c6ba4
WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal uint64 = 0x4068f26bf6d868ae
WithAndWithoutRequestResponseNoRequestWithResponseOrdinal uint64 = 0x447e655905ccfbf4
WithAndWithoutRequestResponseWithRequestNoResponseOrdinal uint64 = 0x7cb47b2f9e76d17d
WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal uint64 = 0x65eb512ff0e1c07e
WithAndWithoutRequestResponseWithRequestWithResponseOrdinal uint64 = 0x1d323510d4447cf1
WithAndWithoutRequestResponseOnEmptyResponseOrdinal uint64 = 0x125c87a592bff029
WithAndWithoutRequestResponseOnWithResponseOrdinal uint64 = 0x177adc0a3ee346c2
)
type WithAndWithoutRequestResponseWithCtxInterface _bindings.ChannelProxy
func (p *WithAndWithoutRequestResponseWithCtxInterface) NoRequestNoResponse(ctx_ _bindings.Context) error {
var req_ _bindings.Message
err_ := ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseNoRequestNoResponseOrdinal, req_)
return err_
}
func (p *WithAndWithoutRequestResponseWithCtxInterface) NoRequestEmptyResponse(ctx_ _bindings.Context) error {
var req_ _bindings.Message
var resp_ _bindings.Message
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal, req_, resp_)
return err_
}
func (p *WithAndWithoutRequestResponseWithCtxInterface) NoRequestWithResponse(ctx_ _bindings.Context) (string, error) {
var req_ _bindings.Message
resp_ := &withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseNoRequestWithResponseOrdinal, req_, resp_)
return resp_.Ret, err_
}
func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestNoResponse(ctx_ _bindings.Context, arg string) error {
req_ := &withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{
Arg: arg,
}
err_ := ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseWithRequestNoResponseOrdinal, req_)
return err_
}
func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestEmptyResponse(ctx_ _bindings.Context, arg string) error {
req_ := &withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest{
Arg: arg,
}
var resp_ _bindings.Message
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal, req_, resp_)
return err_
}
func (p *WithAndWithoutRequestResponseWithCtxInterface) WithRequestWithResponse(ctx_ _bindings.Context, arg string) (string, error) {
req_ := &withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest{
Arg: arg,
}
resp_ := &withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithAndWithoutRequestResponseWithRequestWithResponseOrdinal, req_, resp_)
return resp_.Ret, err_
}
func (p *WithAndWithoutRequestResponseWithCtxInterface) ExpectOnEmptyResponse(ctx_ _bindings.Context) error {
var resp_ _bindings.Message
err_ := ((*_bindings.ChannelProxy)(p)).Recv(WithAndWithoutRequestResponseOnEmptyResponseOrdinal, resp_)
return err_
}
func (p *WithAndWithoutRequestResponseWithCtxInterface) ExpectOnWithResponse(ctx_ _bindings.Context) (string, error) {
resp_ := &withAndWithoutRequestResponseWithCtxOnWithResponseResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Recv(WithAndWithoutRequestResponseOnWithResponseOrdinal, resp_)
return resp_.Ret, err_
}
type WithAndWithoutRequestResponseWithCtx interface {
NoRequestNoResponse(ctx_ _bindings.Context) error
NoRequestEmptyResponse(ctx_ _bindings.Context) error
NoRequestWithResponse(ctx_ _bindings.Context) (string, error)
WithRequestNoResponse(ctx_ _bindings.Context, arg string) error
WithRequestEmptyResponse(ctx_ _bindings.Context, arg string) error
WithRequestWithResponse(ctx_ _bindings.Context, arg string) (string, error)
}
type WithAndWithoutRequestResponseWithCtxTransitionalBase struct{}
type WithAndWithoutRequestResponseWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewWithAndWithoutRequestResponseWithCtxInterfaceRequest() (WithAndWithoutRequestResponseWithCtxInterfaceRequest, *WithAndWithoutRequestResponseWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return WithAndWithoutRequestResponseWithCtxInterfaceRequest(req), (*WithAndWithoutRequestResponseWithCtxInterface)(cli), err
}
type WithAndWithoutRequestResponseWithCtxStub struct {
Impl WithAndWithoutRequestResponseWithCtx
}
func (s_ *WithAndWithoutRequestResponseWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case WithAndWithoutRequestResponseNoRequestNoResponseOrdinal:
err_ := s_.Impl.NoRequestNoResponse(args_.Ctx)
return nil, false, err_
case WithAndWithoutRequestResponseNoRequestEmptyResponseOrdinal:
err_ := s_.Impl.NoRequestEmptyResponse(args_.Ctx)
return nil, true, err_
case WithAndWithoutRequestResponseNoRequestWithResponseOrdinal:
ret, err_ := s_.Impl.NoRequestWithResponse(args_.Ctx)
out_ := withAndWithoutRequestResponseWithCtxNoRequestWithResponseResponse{}
out_.Ret = ret
return &out_, true, err_
case WithAndWithoutRequestResponseWithRequestNoResponseOrdinal:
in_ := withAndWithoutRequestResponseWithCtxWithRequestNoResponseRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
err_ := s_.Impl.WithRequestNoResponse(args_.Ctx, in_.Arg)
return nil, false, err_
case WithAndWithoutRequestResponseWithRequestEmptyResponseOrdinal:
in_ := withAndWithoutRequestResponseWithCtxWithRequestEmptyResponseRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
err_ := s_.Impl.WithRequestEmptyResponse(args_.Ctx, in_.Arg)
return nil, true, err_
case WithAndWithoutRequestResponseWithRequestWithResponseOrdinal:
in_ := withAndWithoutRequestResponseWithCtxWithRequestWithResponseRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
ret, err_ := s_.Impl.WithRequestWithResponse(args_.Ctx, in_.Arg)
out_ := withAndWithoutRequestResponseWithCtxWithRequestWithResponseResponse{}
out_.Ret = ret
return &out_, true, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type WithAndWithoutRequestResponseEventProxy _bindings.ChannelProxy
func (p *WithAndWithoutRequestResponseEventProxy) OnEmptyResponse() error {
var event_ _bindings.Message
return ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseOnEmptyResponseOrdinal, event_)
}
func (p *WithAndWithoutRequestResponseEventProxy) OnWithResponse(ret string) error {
event_ := &withAndWithoutRequestResponseWithCtxOnWithResponseResponse{
Ret: ret,
}
return ((*_bindings.ChannelProxy)(p)).Send(WithAndWithoutRequestResponseOnWithResponseOrdinal, event_)
}
const (
WithErrorSyntaxResponseAsStructOrdinal uint64 = 0x3784d38864674290
WithErrorSyntaxErrorAsPrimitiveOrdinal uint64 = 0x2f7c390f3cdef4ce
WithErrorSyntaxErrorAsEnumOrdinal uint64 = 0x8b550d7c29f740c
WithErrorSyntaxHandleInResultOrdinal uint64 = 0x1dcf0cfb09e14f97
)
type WithErrorSyntaxWithCtxInterface _bindings.ChannelProxy
func (p *WithErrorSyntaxWithCtxInterface) ResponseAsStruct(ctx_ _bindings.Context) (WithErrorSyntaxResponseAsStructResult, error) {
var req_ _bindings.Message
resp_ := &withErrorSyntaxWithCtxResponseAsStructResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxResponseAsStructOrdinal, req_, resp_)
return resp_.Result, err_
}
func (p *WithErrorSyntaxWithCtxInterface) ErrorAsPrimitive(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsPrimitiveResult, error) {
var req_ _bindings.Message
resp_ := &withErrorSyntaxWithCtxErrorAsPrimitiveResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxErrorAsPrimitiveOrdinal, req_, resp_)
return resp_.Result, err_
}
func (p *WithErrorSyntaxWithCtxInterface) ErrorAsEnum(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsEnumResult, error) {
var req_ _bindings.Message
resp_ := &withErrorSyntaxWithCtxErrorAsEnumResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxErrorAsEnumOrdinal, req_, resp_)
return resp_.Result, err_
}
func (p *WithErrorSyntaxWithCtxInterface) HandleInResult(ctx_ _bindings.Context) (WithErrorSyntaxHandleInResultResult, error) {
var req_ _bindings.Message
resp_ := &withErrorSyntaxWithCtxHandleInResultResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithErrorSyntaxHandleInResultOrdinal, req_, resp_)
return resp_.Result, err_
}
type WithErrorSyntaxWithCtx interface {
ResponseAsStruct(ctx_ _bindings.Context) (WithErrorSyntaxResponseAsStructResult, error)
ErrorAsPrimitive(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsPrimitiveResult, error)
ErrorAsEnum(ctx_ _bindings.Context) (WithErrorSyntaxErrorAsEnumResult, error)
HandleInResult(ctx_ _bindings.Context) (WithErrorSyntaxHandleInResultResult, error)
}
type WithErrorSyntaxWithCtxTransitionalBase struct{}
type WithErrorSyntaxWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewWithErrorSyntaxWithCtxInterfaceRequest() (WithErrorSyntaxWithCtxInterfaceRequest, *WithErrorSyntaxWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return WithErrorSyntaxWithCtxInterfaceRequest(req), (*WithErrorSyntaxWithCtxInterface)(cli), err
}
type WithErrorSyntaxWithCtxStub struct {
Impl WithErrorSyntaxWithCtx
}
func (s_ *WithErrorSyntaxWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case WithErrorSyntaxResponseAsStructOrdinal:
result, err_ := s_.Impl.ResponseAsStruct(args_.Ctx)
out_ := withErrorSyntaxWithCtxResponseAsStructResponse{}
out_.Result = result
return &out_, true, err_
case WithErrorSyntaxErrorAsPrimitiveOrdinal:
result, err_ := s_.Impl.ErrorAsPrimitive(args_.Ctx)
out_ := withErrorSyntaxWithCtxErrorAsPrimitiveResponse{}
out_.Result = result
return &out_, true, err_
case WithErrorSyntaxErrorAsEnumOrdinal:
result, err_ := s_.Impl.ErrorAsEnum(args_.Ctx)
out_ := withErrorSyntaxWithCtxErrorAsEnumResponse{}
out_.Result = result
return &out_, true, err_
case WithErrorSyntaxHandleInResultOrdinal:
result, err_ := s_.Impl.HandleInResult(args_.Ctx)
out_ := withErrorSyntaxWithCtxHandleInResultResponse{}
out_.Result = result
return &out_, true, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type WithErrorSyntaxEventProxy _bindings.ChannelProxy
const (
ChannelProtocolMethodAOrdinal uint64 = 0x7d92c10fb2d002e
ChannelProtocolEventAOrdinal uint64 = 0x52c2fa481a687dfa
ChannelProtocolMethodBOrdinal uint64 = 0x5da1d2ed00055cea
ChannelProtocolTakeHandleOrdinal uint64 = 0xc25674355065c28
ChannelProtocolMutateSocketOrdinal uint64 = 0x7dd036a18b33b76a
)
type ChannelProtocolWithCtxInterface _bindings.ChannelProxy
func (p *ChannelProtocolWithCtxInterface) MethodA(ctx_ _bindings.Context, a int64, b int64) error {
req_ := &channelProtocolWithCtxMethodARequest{
A: a,
B: b,
}
err_ := ((*_bindings.ChannelProxy)(p)).Send(ChannelProtocolMethodAOrdinal, req_)
return err_
}
func (p *ChannelProtocolWithCtxInterface) ExpectEventA(ctx_ _bindings.Context) (int64, int64, error) {
resp_ := &channelProtocolWithCtxEventAResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Recv(ChannelProtocolEventAOrdinal, resp_)
return resp_.A, resp_.B, err_
}
func (p *ChannelProtocolWithCtxInterface) MethodB(ctx_ _bindings.Context, a int64, b int64) (int64, error) {
req_ := &channelProtocolWithCtxMethodBRequest{
A: a,
B: b,
}
resp_ := &channelProtocolWithCtxMethodBResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolMethodBOrdinal, req_, resp_)
return resp_.Result, err_
}
func (p *ChannelProtocolWithCtxInterface) TakeHandle(ctx_ _bindings.Context, h _zx.Handle) error {
req_ := &channelProtocolWithCtxTakeHandleRequest{
H: h,
}
var resp_ _bindings.Message
err_ := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolTakeHandleOrdinal, req_, resp_)
return err_
}
func (p *ChannelProtocolWithCtxInterface) MutateSocket(ctx_ _bindings.Context, a _zx.Socket) (_zx.Socket, error) {
req_ := &channelProtocolWithCtxMutateSocketRequest{
A: a,
}
resp_ := &channelProtocolWithCtxMutateSocketResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(ChannelProtocolMutateSocketOrdinal, req_, resp_)
return resp_.B, err_
}
type ChannelProtocolWithCtx interface {
MethodA(ctx_ _bindings.Context, a int64, b int64) error
MethodB(ctx_ _bindings.Context, a int64, b int64) (int64, error)
TakeHandle(ctx_ _bindings.Context, h _zx.Handle) error
MutateSocket(ctx_ _bindings.Context, a _zx.Socket) (_zx.Socket, error)
}
type ChannelProtocolWithCtxTransitionalBase struct{}
type ChannelProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewChannelProtocolWithCtxInterfaceRequest() (ChannelProtocolWithCtxInterfaceRequest, *ChannelProtocolWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return ChannelProtocolWithCtxInterfaceRequest(req), (*ChannelProtocolWithCtxInterface)(cli), err
}
type ChannelProtocolWithCtxStub struct {
Impl ChannelProtocolWithCtx
}
func (s_ *ChannelProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case ChannelProtocolMethodAOrdinal:
in_ := channelProtocolWithCtxMethodARequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
err_ := s_.Impl.MethodA(args_.Ctx, in_.A, in_.B)
return nil, false, err_
case ChannelProtocolMethodBOrdinal:
in_ := channelProtocolWithCtxMethodBRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
result, err_ := s_.Impl.MethodB(args_.Ctx, in_.A, in_.B)
out_ := channelProtocolWithCtxMethodBResponse{}
out_.Result = result
return &out_, true, err_
case ChannelProtocolTakeHandleOrdinal:
in_ := channelProtocolWithCtxTakeHandleRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
err_ := s_.Impl.TakeHandle(args_.Ctx, in_.H)
return nil, true, err_
case ChannelProtocolMutateSocketOrdinal:
in_ := channelProtocolWithCtxMutateSocketRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
b, err_ := s_.Impl.MutateSocket(args_.Ctx, in_.A)
out_ := channelProtocolWithCtxMutateSocketResponse{}
out_.B = b
return &out_, true, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type ChannelProtocolEventProxy _bindings.ChannelProxy
func (p *ChannelProtocolEventProxy) EventA(a int64, b int64) error {
event_ := &channelProtocolWithCtxEventAResponse{
A: a,
B: b,
}
return ((*_bindings.ChannelProxy)(p)).Send(ChannelProtocolEventAOrdinal, event_)
}
const (
TransitionalRequestOrdinal uint64 = 0x62d345e621780ee8
TransitionalOneWayOrdinal uint64 = 0xf99bc4b26bc9ea5
TransitionalEventOrdinal uint64 = 0x53bb9212bcbe8966
)
type TransitionalWithCtxInterface _bindings.ChannelProxy
func (p *TransitionalWithCtxInterface) Request(ctx_ _bindings.Context, x int64) (int64, error) {
req_ := &transitionalWithCtxRequestRequest{
X: x,
}
resp_ := &transitionalWithCtxRequestResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(TransitionalRequestOrdinal, req_, resp_)
return resp_.Y, err_
}
func (p *TransitionalWithCtxInterface) OneWay(ctx_ _bindings.Context, x int64) error {
req_ := &transitionalWithCtxOneWayRequest{
X: x,
}
err_ := ((*_bindings.ChannelProxy)(p)).Send(TransitionalOneWayOrdinal, req_)
return err_
}
func (p *TransitionalWithCtxInterface) ExpectEvent(ctx_ _bindings.Context) (int64, error) {
resp_ := &transitionalWithCtxEventResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Recv(TransitionalEventOrdinal, resp_)
return resp_.X, err_
}
type TransitionalWithCtx interface {
Request(ctx_ _bindings.Context, x int64) (int64, error)
OneWay(ctx_ _bindings.Context, x int64) error
}
type TransitionalWithCtxTransitionalBase struct{}
func (_ *TransitionalWithCtxTransitionalBase) Request(ctx_ _bindings.Context, x int64) (int64, error) {
panic("Not Implemented")
}
func (_ *TransitionalWithCtxTransitionalBase) OneWay(ctx_ _bindings.Context, x int64) error {
panic("Not Implemented")
}
type TransitionalWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewTransitionalWithCtxInterfaceRequest() (TransitionalWithCtxInterfaceRequest, *TransitionalWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return TransitionalWithCtxInterfaceRequest(req), (*TransitionalWithCtxInterface)(cli), err
}
type TransitionalWithCtxStub struct {
Impl TransitionalWithCtx
}
func (s_ *TransitionalWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case TransitionalRequestOrdinal:
in_ := transitionalWithCtxRequestRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
y, err_ := s_.Impl.Request(args_.Ctx, in_.X)
out_ := transitionalWithCtxRequestResponse{}
out_.Y = y
return &out_, true, err_
case TransitionalOneWayOrdinal:
in_ := transitionalWithCtxOneWayRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
err_ := s_.Impl.OneWay(args_.Ctx, in_.X)
return nil, false, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type TransitionalEventProxy _bindings.ChannelProxy
func (p *TransitionalEventProxy) Event(x int64) error {
event_ := &transitionalWithCtxEventResponse{
X: x,
}
return ((*_bindings.ChannelProxy)(p)).Send(TransitionalEventOrdinal, event_)
}
const (
DiscoverableProtocolMethodOrdinal uint64 = 0x39790af74e0167
)
type DiscoverableProtocolWithCtxInterface _bindings.ChannelProxy
func (p *DiscoverableProtocolWithCtxInterface) Method(ctx_ _bindings.Context) error {
var req_ _bindings.Message
err_ := ((*_bindings.ChannelProxy)(p)).Send(DiscoverableProtocolMethodOrdinal, req_)
return err_
}
type DiscoverableProtocolWithCtx interface {
Method(ctx_ _bindings.Context) error
}
type DiscoverableProtocolWithCtxTransitionalBase struct{}
type DiscoverableProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewDiscoverableProtocolWithCtxInterfaceRequest() (DiscoverableProtocolWithCtxInterfaceRequest, *DiscoverableProtocolWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return DiscoverableProtocolWithCtxInterfaceRequest(req), (*DiscoverableProtocolWithCtxInterface)(cli), err
}
// Implements ServiceRequest.
func (_ DiscoverableProtocolWithCtxInterfaceRequest) Name() string {
return "fidl.test.protocols.DiscoverableProtocol"
}
func (c DiscoverableProtocolWithCtxInterfaceRequest) ToChannel() _zx.Channel {
return c.Channel
}
const DiscoverableProtocolName = "fidl.test.protocols.DiscoverableProtocol"
type DiscoverableProtocolWithCtxStub struct {
Impl DiscoverableProtocolWithCtx
}
func (s_ *DiscoverableProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case DiscoverableProtocolMethodOrdinal:
err_ := s_.Impl.Method(args_.Ctx)
return nil, false, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type DiscoverableProtocolEventProxy _bindings.ChannelProxy
const (
HandleRightsProtocolNoResponseMethodOrdinal uint64 = 0x466a6fe3be0bcb7c
HandleRightsProtocolResponseMethodOrdinal uint64 = 0x5ef2bd2bbb280ffc
HandleRightsProtocolAnEventOrdinal uint64 = 0xce6b76255d6ed71
)
type HandleRightsProtocolWithCtxInterface _bindings.ChannelProxy
func (p *HandleRightsProtocolWithCtxInterface) NoResponseMethod(ctx_ _bindings.Context, h _zx.Socket) error {
req_ := &handleRightsProtocolWithCtxNoResponseMethodRequest{
H: h,
}
err_ := ((*_bindings.ChannelProxy)(p)).Send(HandleRightsProtocolNoResponseMethodOrdinal, req_)
return err_
}
func (p *HandleRightsProtocolWithCtxInterface) ResponseMethod(ctx_ _bindings.Context, h _zx.Socket) (_zx.Socket, error) {
req_ := &handleRightsProtocolWithCtxResponseMethodRequest{
H: h,
}
resp_ := &handleRightsProtocolWithCtxResponseMethodResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(HandleRightsProtocolResponseMethodOrdinal, req_, resp_)
return resp_.H, err_
}
func (p *HandleRightsProtocolWithCtxInterface) ExpectAnEvent(ctx_ _bindings.Context) (_zx.Socket, error) {
resp_ := &handleRightsProtocolWithCtxAnEventResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Recv(HandleRightsProtocolAnEventOrdinal, resp_)
return resp_.H, err_
}
type HandleRightsProtocolWithCtx interface {
NoResponseMethod(ctx_ _bindings.Context, h _zx.Socket) error
ResponseMethod(ctx_ _bindings.Context, h _zx.Socket) (_zx.Socket, error)
}
type HandleRightsProtocolWithCtxTransitionalBase struct{}
type HandleRightsProtocolWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewHandleRightsProtocolWithCtxInterfaceRequest() (HandleRightsProtocolWithCtxInterfaceRequest, *HandleRightsProtocolWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return HandleRightsProtocolWithCtxInterfaceRequest(req), (*HandleRightsProtocolWithCtxInterface)(cli), err
}
type HandleRightsProtocolWithCtxStub struct {
Impl HandleRightsProtocolWithCtx
}
func (s_ *HandleRightsProtocolWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case HandleRightsProtocolNoResponseMethodOrdinal:
in_ := handleRightsProtocolWithCtxNoResponseMethodRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
err_ := s_.Impl.NoResponseMethod(args_.Ctx, in_.H)
return nil, false, err_
case HandleRightsProtocolResponseMethodOrdinal:
in_ := handleRightsProtocolWithCtxResponseMethodRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
h, err_ := s_.Impl.ResponseMethod(args_.Ctx, in_.H)
out_ := handleRightsProtocolWithCtxResponseMethodResponse{}
out_.H = h
return &out_, true, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type HandleRightsProtocolEventProxy _bindings.ChannelProxy
func (p *HandleRightsProtocolEventProxy) AnEvent(h _zx.Socket) error {
event_ := &handleRightsProtocolWithCtxAnEventResponse{
H: h,
}
return ((*_bindings.ChannelProxy)(p)).Send(HandleRightsProtocolAnEventOrdinal, event_)
}
const (
WithProtocolEndsClientEndsOrdinal uint64 = 0x60b18491ac8062ad
WithProtocolEndsServerEndsOrdinal uint64 = 0x3e5b3b503a05a17c
WithProtocolEndsStructContainingEndsOrdinal uint64 = 0x26f2c10b743415c
)
type WithProtocolEndsWithCtxInterface _bindings.ChannelProxy
func (p *WithProtocolEndsWithCtxInterface) ClientEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterface) (DiscoverableProtocolWithCtxInterface, error) {
req_ := &withProtocolEndsWithCtxClientEndsRequest{
In: in,
}
resp_ := &withProtocolEndsWithCtxClientEndsResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithProtocolEndsClientEndsOrdinal, req_, resp_)
return resp_.Out, err_
}
func (p *WithProtocolEndsWithCtxInterface) ServerEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterfaceRequest) (DiscoverableProtocolWithCtxInterfaceRequest, error) {
req_ := &withProtocolEndsWithCtxServerEndsRequest{
In: in,
}
resp_ := &withProtocolEndsWithCtxServerEndsResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithProtocolEndsServerEndsOrdinal, req_, resp_)
return resp_.Out, err_
}
func (p *WithProtocolEndsWithCtxInterface) StructContainingEnds(ctx_ _bindings.Context, in ProtocolEnds) (ProtocolEnds, error) {
req_ := &withProtocolEndsWithCtxStructContainingEndsRequest{
In: in,
}
resp_ := &withProtocolEndsWithCtxStructContainingEndsResponse{}
err_ := ((*_bindings.ChannelProxy)(p)).Call(WithProtocolEndsStructContainingEndsOrdinal, req_, resp_)
return resp_.Out, err_
}
type WithProtocolEndsWithCtx interface {
ClientEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterface) (DiscoverableProtocolWithCtxInterface, error)
ServerEnds(ctx_ _bindings.Context, in DiscoverableProtocolWithCtxInterfaceRequest) (DiscoverableProtocolWithCtxInterfaceRequest, error)
StructContainingEnds(ctx_ _bindings.Context, in ProtocolEnds) (ProtocolEnds, error)
}
type WithProtocolEndsWithCtxTransitionalBase struct{}
type WithProtocolEndsWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewWithProtocolEndsWithCtxInterfaceRequest() (WithProtocolEndsWithCtxInterfaceRequest, *WithProtocolEndsWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return WithProtocolEndsWithCtxInterfaceRequest(req), (*WithProtocolEndsWithCtxInterface)(cli), err
}
type WithProtocolEndsWithCtxStub struct {
Impl WithProtocolEndsWithCtx
}
func (s_ *WithProtocolEndsWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case WithProtocolEndsClientEndsOrdinal:
in_ := withProtocolEndsWithCtxClientEndsRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
out, err_ := s_.Impl.ClientEnds(args_.Ctx, in_.In)
out_ := withProtocolEndsWithCtxClientEndsResponse{}
out_.Out = out
return &out_, true, err_
case WithProtocolEndsServerEndsOrdinal:
in_ := withProtocolEndsWithCtxServerEndsRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
out, err_ := s_.Impl.ServerEnds(args_.Ctx, in_.In)
out_ := withProtocolEndsWithCtxServerEndsResponse{}
out_.Out = out
return &out_, true, err_
case WithProtocolEndsStructContainingEndsOrdinal:
in_ := withProtocolEndsWithCtxStructContainingEndsRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
out, err_ := s_.Impl.StructContainingEnds(args_.Ctx, in_.In)
out_ := withProtocolEndsWithCtxStructContainingEndsResponse{}
out_.Out = out
return &out_, true, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type WithProtocolEndsEventProxy _bindings.ChannelProxy
const (
ManyParametersFifteenOrdinal uint64 = 0x295ae26a080f53e3
)
type ManyParametersWithCtxInterface _bindings.ChannelProxy
func (p *ManyParametersWithCtxInterface) Fifteen(ctx_ _bindings.Context, p1 bool, p2 bool, p3 bool, p4 bool, p5 bool, p6 bool, p7 bool, p8 bool, p9 bool, p10 bool, p11 bool, p12 bool, p13 bool, p14 bool, p15 bool) error {
req_ := &manyParametersWithCtxFifteenRequest{
P1: p1,
P2: p2,
P3: p3,
P4: p4,
P5: p5,
P6: p6,
P7: p7,
P8: p8,
P9: p9,
P10: p10,
P11: p11,
P12: p12,
P13: p13,
P14: p14,
P15: p15,
}
err_ := ((*_bindings.ChannelProxy)(p)).Send(ManyParametersFifteenOrdinal, req_)
return err_
}
type ManyParametersWithCtx interface {
Fifteen(ctx_ _bindings.Context, p1 bool, p2 bool, p3 bool, p4 bool, p5 bool, p6 bool, p7 bool, p8 bool, p9 bool, p10 bool, p11 bool, p12 bool, p13 bool, p14 bool, p15 bool) error
}
type ManyParametersWithCtxTransitionalBase struct{}
type ManyParametersWithCtxInterfaceRequest _bindings.InterfaceRequest
func NewManyParametersWithCtxInterfaceRequest() (ManyParametersWithCtxInterfaceRequest, *ManyParametersWithCtxInterface, error) {
req, cli, err := _bindings.NewInterfaceRequest()
return ManyParametersWithCtxInterfaceRequest(req), (*ManyParametersWithCtxInterface)(cli), err
}
type ManyParametersWithCtxStub struct {
Impl ManyParametersWithCtx
}
func (s_ *ManyParametersWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) {
switch args_.Ordinal {
case ManyParametersFifteenOrdinal:
in_ := manyParametersWithCtxFifteenRequest{}
marshalerCtx, ok := _bindings.GetMarshalerContext(args_.Ctx)
if !ok {
return nil, false, _bindings.ErrMissingMarshalerContext
}
if _, _, err_ := _bindings.UnmarshalWithContext2(marshalerCtx, args_.Bytes, args_.HandleInfos, &in_); err_ != nil {
return nil, false, err_
}
err_ := s_.Impl.Fifteen(args_.Ctx, in_.P1, in_.P2, in_.P3, in_.P4, in_.P5, in_.P6, in_.P7, in_.P8, in_.P9, in_.P10, in_.P11, in_.P12, in_.P13, in_.P14, in_.P15)
return nil, false, err_
}
return nil, false, _bindings.ErrUnknownOrdinal
}
type ManyParametersEventProxy _bindings.ChannelProxy