| // Code generated by fidlgen; DO NOT EDIT. |
| |
| package doccomments |
| |
| import ( |
| _bindings "syscall/zx/fidl" |
| ) |
| |
| const ( |
| // const comment #1 |
| // |
| // const comment #3 |
| C int32 = 4 |
| ) |
| |
| var _ _bindings.Enum = MyStrictEnum(0) |
| |
| // strict enum comment #1. |
| // |
| // strict enum comment #2. |
| type MyStrictEnum uint32 |
| |
| const ( |
| |
| // FOO member comment #1 |
| // |
| // FOO member comment #3 |
| MyStrictEnumFoo MyStrictEnum = 1 |
| |
| // BAR member comment #1 |
| // |
| // BAR member comment #3 |
| MyStrictEnumBar MyStrictEnum = 2 |
| ) |
| |
| func (_ MyStrictEnum) I_EnumValues() []MyStrictEnum { |
| return []MyStrictEnum{ |
| MyStrictEnumFoo, |
| MyStrictEnumBar, |
| } |
| } |
| |
| func (_ MyStrictEnum) I_EnumIsStrict() bool { |
| return true |
| } |
| |
| func (x MyStrictEnum) IsUnknown() bool { |
| switch x { |
| case 1: |
| return true |
| case 2: |
| return true |
| default: |
| return false |
| } |
| } |
| |
| func (x MyStrictEnum) String() string { |
| switch x { |
| case 1: |
| return "Foo" |
| case 2: |
| return "Bar" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Enum = MyFlexibleEnum(0) |
| |
| // flexible enum comment #1. |
| // |
| // flexible enum comment #2. |
| type MyFlexibleEnum uint32 |
| |
| const ( |
| |
| // FOO member comment #1 |
| // |
| // FOO member comment #3 |
| MyFlexibleEnumFoo MyFlexibleEnum = 1 |
| |
| // BAR member comment #1 |
| // |
| // BAR member comment #3 |
| MyFlexibleEnumBar MyFlexibleEnum = 2 |
| |
| // MyFlexibleEnum_Unknown is the default unknown placeholder. |
| MyFlexibleEnum_Unknown MyFlexibleEnum = 0xffffffff |
| ) |
| |
| func (_ MyFlexibleEnum) I_EnumValues() []MyFlexibleEnum { |
| return []MyFlexibleEnum{ |
| MyFlexibleEnumFoo, |
| MyFlexibleEnumBar, |
| } |
| } |
| |
| func (_ MyFlexibleEnum) I_EnumIsStrict() bool { |
| return false |
| } |
| |
| func (x MyFlexibleEnum) IsUnknown() bool { |
| switch x { |
| case 1: |
| return true |
| case 2: |
| return true |
| default: |
| return false |
| } |
| } |
| |
| func (x MyFlexibleEnum) String() string { |
| switch x { |
| case 1: |
| return "Foo" |
| case 2: |
| return "Bar" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Bits = MyStrictBits(0) |
| |
| // strict bits comment #1 |
| // |
| // strict bits comment #2 |
| type MyStrictBits uint32 |
| |
| const ( |
| MyStrictBitsMyFirstBit MyStrictBits = 1 |
| MyStrictBitsMyOtherBit MyStrictBits = 2 |
| MyStrictBits_Mask MyStrictBits = 3 |
| ) |
| |
| func (_ MyStrictBits) I_BitsMask() MyStrictBits { |
| return MyStrictBits_Mask |
| } |
| |
| func (_ MyStrictBits) I_BitsIsStrict() bool { |
| return true |
| } |
| |
| func (x MyStrictBits) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x MyStrictBits) GetUnknownBits() uint64 { |
| return uint64(^MyStrictBits_Mask & x) |
| } |
| |
| func (x MyStrictBits) InvertBits() MyStrictBits { |
| return MyStrictBits_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x MyStrictBits) HasBits(mask MyStrictBits) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x MyStrictBits) ClearBits(mask MyStrictBits) MyStrictBits { |
| return ^mask & x |
| } |
| |
| func (x MyStrictBits) String() string { |
| switch x { |
| case 1: |
| return "MyFirstBit" |
| case 2: |
| return "MyOtherBit" |
| } |
| return "Unknown" |
| } |
| |
| var _ _bindings.Bits = MyFlexibleBits(0) |
| |
| // flexible bits comment #1 |
| // |
| // flexible bits comment #2 |
| type MyFlexibleBits uint32 |
| |
| const ( |
| MyFlexibleBitsMyFirstBit MyFlexibleBits = 1 |
| MyFlexibleBitsMyOtherBit MyFlexibleBits = 2 |
| MyFlexibleBits_Mask MyFlexibleBits = 3 |
| ) |
| |
| func (_ MyFlexibleBits) I_BitsMask() MyFlexibleBits { |
| return MyFlexibleBits_Mask |
| } |
| |
| func (_ MyFlexibleBits) I_BitsIsStrict() bool { |
| return false |
| } |
| |
| func (x MyFlexibleBits) HasUnknownBits() bool { |
| return x.GetUnknownBits() != 0 |
| } |
| |
| func (x MyFlexibleBits) GetUnknownBits() uint64 { |
| return uint64(^MyFlexibleBits_Mask & x) |
| } |
| |
| func (x MyFlexibleBits) InvertBits() MyFlexibleBits { |
| return MyFlexibleBits_Mask & ^x |
| } |
| |
| // HasBits validates that all flipped bits in the mask are set. |
| func (x MyFlexibleBits) HasBits(mask MyFlexibleBits) bool { |
| return mask|x == x |
| } |
| |
| // ClearBits ensures all flipped bits in the mask are unset. |
| func (x MyFlexibleBits) ClearBits(mask MyFlexibleBits) MyFlexibleBits { |
| return ^mask & x |
| } |
| |
| func (x MyFlexibleBits) String() string { |
| switch x { |
| case 1: |
| return "MyFirstBit" |
| case 2: |
| return "MyOtherBit" |
| } |
| return "Unknown" |
| } |
| |
| // struct comment #1 |
| // |
| // struct comment #3 |
| type Struct struct { |
| _ struct{} `fidl:"s" fidl_size_v1:"4" fidl_alignment_v1:"4"` |
| // struct member comment #1 |
| // |
| // struct member comment #3 |
| Field int32 `fidl_offset_v1:"0"` |
| } |
| |
| var _mStruct = _bindings.CreateLazyMarshaler(Struct{}) |
| |
| func (msg *Struct) Marshaler() _bindings.Marshaler { |
| return _mStruct |
| } |
| |
| type I_strictUnionTag uint64 |
| |
| const ( |
| StrictUnionField = 1 // 0x00000001 |
| ) |
| |
| // strict union comment #1 |
| // |
| // strict union comment #3 |
| type StrictUnion struct { |
| I_strictUnionTag `fidl:"x!" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"` |
| // union member comment #1 |
| // |
| // union member comment #3 |
| Field int32 `fidl_ordinal:"1"` |
| } |
| |
| func (_m *StrictUnion) reset() { |
| switch _m.I_strictUnionTag { |
| case 1: |
| var _zeroed int32 |
| _m.Field = _zeroed |
| } |
| } |
| |
| func (_m *StrictUnion) Which() I_strictUnionTag { |
| return _m.I_strictUnionTag |
| } |
| |
| func (_m *StrictUnion) Ordinal() uint64 { |
| return uint64(_m.I_strictUnionTag) |
| } |
| |
| func (_m *StrictUnion) SetField(field int32) { |
| _m.reset() |
| _m.I_strictUnionTag = StrictUnionField |
| _m.Field = field |
| } |
| |
| func StrictUnionWithField(field int32) StrictUnion { |
| var _u StrictUnion |
| _u.SetField(field) |
| return _u |
| } |
| |
| type I_flexibleUnionTag uint64 |
| |
| const ( |
| FlexibleUnion_unknownData = 0 // 0x00000000 |
| FlexibleUnionField = 1 // 0x00000001 |
| ) |
| |
| // flexible union comment #1 |
| // |
| // flexible union comment #3 |
| type FlexibleUnion struct { |
| I_flexibleUnionTag `fidl:"x" fidl_size_v1:"24" fidl_alignment_v1:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // union member comment #1 |
| // |
| // union member comment #3 |
| Field int32 `fidl_ordinal:"1"` |
| } |
| |
| func (_m *FlexibleUnion) reset() { |
| switch _m.I_flexibleUnionTag { |
| case 1: |
| var _zeroed int32 |
| _m.Field = _zeroed |
| default: |
| var _zeroed interface{} |
| _m.I_unknownData = _zeroed |
| } |
| } |
| |
| func (_m *FlexibleUnion) Which() I_flexibleUnionTag { |
| switch _m.I_flexibleUnionTag { |
| case 1: |
| return FlexibleUnionField |
| default: |
| return FlexibleUnion_unknownData |
| } |
| } |
| |
| func (_m *FlexibleUnion) Ordinal() uint64 { |
| return uint64(_m.I_flexibleUnionTag) |
| } |
| |
| func (_m *FlexibleUnion) SetField(field int32) { |
| _m.reset() |
| _m.I_flexibleUnionTag = FlexibleUnionField |
| _m.Field = field |
| } |
| |
| func FlexibleUnionWithField(field int32) FlexibleUnion { |
| var _u FlexibleUnion |
| _u.SetField(field) |
| return _u |
| } |
| func (_m *FlexibleUnion) GetUnknownData() _bindings.UnknownData { |
| return _m.I_unknownData.(_bindings.UnknownData) |
| } |
| |
| // table comment #1 |
| // |
| // table comment #3 |
| type Table struct { |
| _ struct{} `fidl:"t" fidl_size_v1:"16" fidl_alignment_v1:"8" fidl_resource:"false"` |
| I_unknownData interface{} |
| // table field comment #1 |
| // |
| // table field comment #3 |
| Field int32 `fidl_ordinal:"1"` |
| FieldPresent bool |
| } |
| |
| func (u *Table) SetField(field int32) { |
| u.Field = field |
| u.FieldPresent = true |
| } |
| |
| func (u *Table) GetField() int32 { |
| return u.Field |
| } |
| |
| func (u *Table) GetFieldWithDefault(_default int32) int32 { |
| if !u.HasField() { |
| return _default |
| } |
| return u.Field |
| } |
| |
| func (u *Table) HasField() bool { |
| return u.FieldPresent |
| } |
| |
| func (u *Table) ClearField() { |
| u.FieldPresent = false |
| } |
| |
| func (u *Table) HasUnknownData() bool { |
| return u.I_unknownData != nil |
| } |
| |
| func (u *Table) GetUnknownData() map[uint64]_bindings.UnknownData { |
| return u.I_unknownData.(map[uint64]_bindings.UnknownData) |
| } |
| |
| const ( |
| InterfaceMethodOrdinal uint64 = 0x5c492542705b4265 |
| InterfaceOnEventOrdinal uint64 = 0x37812b697096f6fa |
| ) |
| |
| type InterfaceWithCtxInterface _bindings.ChannelProxy |
| |
| // method comment #1 |
| // |
| // method comment #3 |
| func (p *InterfaceWithCtxInterface) Method(ctx_ _bindings.Context) error { |
| var req_ _bindings.Message |
| err_ := ((*_bindings.ChannelProxy)(p)).Send(InterfaceMethodOrdinal, req_) |
| return err_ |
| } |
| |
| // event comment #1 |
| // |
| // event comment #3 |
| func (p *InterfaceWithCtxInterface) ExpectOnEvent(ctx_ _bindings.Context) error { |
| var resp_ _bindings.Message |
| err_ := ((*_bindings.ChannelProxy)(p)).Recv(InterfaceOnEventOrdinal, resp_) |
| return err_ |
| } |
| |
| // interface comment #1 |
| // |
| // interface comment #3 |
| type InterfaceWithCtx interface { |
| // method comment #1 |
| // |
| // method comment #3 |
| Method(ctx_ _bindings.Context) error |
| // event comment #1 |
| // |
| // event comment #3 |
| } |
| |
| type InterfaceWithCtxTransitionalBase struct{} |
| |
| type InterfaceWithCtxInterfaceRequest _bindings.InterfaceRequest |
| |
| func NewInterfaceWithCtxInterfaceRequest() (InterfaceWithCtxInterfaceRequest, *InterfaceWithCtxInterface, error) { |
| req, cli, err := _bindings.NewInterfaceRequest() |
| return InterfaceWithCtxInterfaceRequest(req), (*InterfaceWithCtxInterface)(cli), err |
| } |
| |
| type InterfaceWithCtxStub struct { |
| Impl InterfaceWithCtx |
| } |
| |
| func (s_ *InterfaceWithCtxStub) Dispatch(args_ _bindings.DispatchArgs) (_bindings.Message, bool, error) { |
| switch args_.Ordinal { |
| case InterfaceMethodOrdinal: |
| err_ := s_.Impl.Method(args_.Ctx) |
| return nil, false, err_ |
| } |
| return nil, false, _bindings.ErrUnknownOrdinal |
| } |
| |
| type InterfaceEventProxy _bindings.ChannelProxy |
| |
| func (p *InterfaceEventProxy) OnEvent() error { |
| var event_ _bindings.Message |
| return ((*_bindings.ChannelProxy)(p)).Send(InterfaceOnEventOrdinal, event_) |
| } |