| // Copyright 2019 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| library test.fidlcodec.examples; | |
| using zx; | |
| closed protocol Echo { | |
| strict EchoString(struct { | |
| value string:<100, optional>; | |
| }) -> (struct { | |
| response string:<100, optional>; | |
| }); | |
| }; | |
| type Named = struct { | |
| s string:200; | |
| }; | |
| closed protocol FidlCodecTestProtocol { | |
| strict Empty(); | |
| strict String(struct { | |
| s string:100; | |
| }); | |
| strict Named(Named); | |
| strict Bool(struct { | |
| b bool; | |
| }); | |
| strict Int8(struct { | |
| i8 int8; | |
| }); | |
| strict Int16(struct { | |
| i16 int16; | |
| }); | |
| strict Int32(struct { | |
| i32 int32; | |
| }); | |
| strict Int64(struct { | |
| i64 int64; | |
| }); | |
| strict Uint8(struct { | |
| ui8 uint8; | |
| }); | |
| strict Uint16(struct { | |
| ui16 uint16; | |
| }); | |
| strict Uint32(struct { | |
| ui32 uint32; | |
| }); | |
| strict Uint64(struct { | |
| ui64 uint64; | |
| }); | |
| strict Float32(struct { | |
| f32 float32; | |
| }); | |
| strict Float64(struct { | |
| f64 float64; | |
| }); | |
| strict Complex(struct { | |
| real int32; | |
| imaginary int32; | |
| }); | |
| strict StringInt(struct { | |
| s string:100; | |
| i32 int32; | |
| }); | |
| strict StringIntTable(table { | |
| 1: s string:100; | |
| 2: i32 int32; | |
| }); | |
| strict StringIntUnion(union { | |
| 1: s string:100; | |
| 2: i32 int32; | |
| }); | |
| strict Array1(struct { | |
| b_1 array<int32, 1>; | |
| }); | |
| strict Array2(struct { | |
| b_2 array<int32, 2>; | |
| }); | |
| strict Vector(struct { | |
| v_1 vector<int32>:<10, optional>; | |
| }); | |
| strict TwoStringArrayInt(struct { | |
| arr array<string:100, 2>; | |
| i32 int32; | |
| }); | |
| strict TwoStringVectorInt(struct { | |
| vec vector<string:100>:10; | |
| i32 int32; | |
| }); | |
| strict TwoStringVectors(struct { | |
| v_1 vector<string:100>:10; | |
| v_2 vector<string:100>:10; | |
| }); | |
| strict VectorUint8(struct { | |
| v vector<uint8>:100; | |
| }); | |
| strict VectorUint32(struct { | |
| v vector<uint32>:100; | |
| }); | |
| strict VectorStruct(struct { | |
| v vector<SmallStruct>:100; | |
| }); | |
| strict ArrayStruct(struct { | |
| a array<SmallStruct, 3>; | |
| }); | |
| strict VectorStruct2(struct { | |
| v vector<SmallUnevenStruct>:100; | |
| }); | |
| strict ArrayStruct2(struct { | |
| a array<SmallUnevenStruct, 3>; | |
| }); | |
| strict Struct(struct { | |
| p PrimitiveTypes; | |
| }); | |
| strict BoolStruct(struct { | |
| s BoolStructType; | |
| }); | |
| strict NullableStruct(struct { | |
| p box<PrimitiveTypes>; | |
| }); | |
| strict NullableStructAndInt(struct { | |
| p box<PrimitiveTypes>; | |
| i int32; | |
| }); | |
| strict ArrayNullableStruct(struct { | |
| a array<box<TwoStringStruct>, 3>; | |
| }); | |
| strict SmallStructAfterByte(struct { | |
| u uint8; | |
| s1 SmallStruct; | |
| s2 SmallStruct; | |
| }); | |
| strict TwoStringStructInt(struct { | |
| s TwoStringStruct; | |
| i32 int32; | |
| }); | |
| strict TwoStringNullableStructInt(struct { | |
| s box<TwoStringStruct>; | |
| i32 int32; | |
| }); | |
| strict Union(struct { | |
| isu IntStructUnion; | |
| i int32; | |
| }); | |
| strict NullableUnion(struct { | |
| isu IntStructUnion:optional; | |
| i int32; | |
| }); | |
| strict NullableUnionIntFirst(struct { | |
| i int32; | |
| isu IntStructUnion:optional; | |
| }); | |
| strict ArrayNullableUnion(struct { | |
| a array<IntStructUnion:optional, 3>; | |
| }); | |
| strict XUnion(struct { | |
| isu IntStructXunion; | |
| i int32; | |
| }); | |
| strict NullableXUnion(struct { | |
| isu IntStructXunion:optional; | |
| i int32; | |
| }); | |
| strict NullableXUnionIntFirst(struct { | |
| i int32; | |
| isu IntStructXunion:optional; | |
| }); | |
| strict ShortUnion(struct { | |
| u U8U16Union; | |
| i int32; | |
| }); | |
| strict ShortUnionReserved(struct { | |
| u U8U16UnionReserved; | |
| i int32; | |
| }); | |
| strict ShortXUnion(struct { | |
| u U8U16Xunion; | |
| i int32; | |
| }); | |
| strict RecursiveUnion(struct { | |
| e DataElement; | |
| }); | |
| strict U8U16UnionStruct(struct { | |
| s U8U16UnionStructType; | |
| }); | |
| strict DefaultEnumMessage(struct { | |
| ev DefaultEnum; | |
| }); | |
| strict I8EnumMessage(struct { | |
| ev I8Enum; | |
| }); | |
| strict I16EnumMessage(struct { | |
| ev I16Enum; | |
| }); | |
| strict I32EnumMessage(struct { | |
| ev I32Enum; | |
| }); | |
| strict I64EnumMessage(struct { | |
| ev I64Enum; | |
| }); | |
| strict DefaultBitsMessage(struct { | |
| v DefaultBits; | |
| }); | |
| strict I8BitsMessage(struct { | |
| v I8Bits; | |
| }); | |
| strict I16BitsMessage(struct { | |
| v I16Bits; | |
| }); | |
| strict I32BitsMessage(struct { | |
| v I32Bits; | |
| }); | |
| strict I64BitsMessage(struct { | |
| v I64Bits; | |
| }); | |
| strict Table(struct { | |
| table ValueTable; | |
| i int32; | |
| }); | |
| strict Handle(resource struct { | |
| ch zx.Handle:CHANNEL; | |
| }); | |
| strict NullableHandle(resource struct { | |
| ch zx.Handle:<CHANNEL, optional>; | |
| }); | |
| strict HandleStructMessage(resource struct { | |
| hs HandleStruct; | |
| }); | |
| strict HandleTableMessage(resource struct { | |
| t HandleTable; | |
| }); | |
| strict TraversalOrderMessage(resource struct { | |
| t TraversalOrder; | |
| }); | |
| strict TraversalMainMessage(resource struct { | |
| v vector<box<TraversalMain>>:3; | |
| s box<TraversalStruct>; | |
| }); | |
| // Named ProtocolMethod because the natural bindings | |
| // do not support a method named Protocol. | |
| strict ProtocolMethod(resource struct { | |
| ch client_end:ParamProtocol; | |
| }); | |
| }; | |
| type BoolStructType = struct { | |
| b bool; | |
| }; | |
| type PrimitiveTypes = struct { | |
| s string:100; | |
| b bool; | |
| i8 int8; | |
| i16 int16; | |
| i32 int32; | |
| i64 int64; | |
| u8 uint8; | |
| u16 uint16; | |
| u32 uint32; | |
| u64 uint64; | |
| f32 float32; | |
| f64 float64; | |
| }; | |
| type SmallStruct = struct { | |
| a uint8; | |
| b uint8; | |
| c uint8; | |
| }; | |
| type SmallUnevenStruct = struct { | |
| a uint32; | |
| b uint8; | |
| }; | |
| type TwoStringStruct = struct { | |
| value1 string:100; | |
| value2 string:100; | |
| }; | |
| type IntStructUnion = strict union { | |
| 1: variant_i int32; | |
| 2: variant_tss TwoStringStruct; | |
| }; | |
| type IntStructXunion = flexible union { | |
| 1: variant_i int32; | |
| 2: variant_tss TwoStringStruct; | |
| }; | |
| type U8U16Union = strict union { | |
| 1: variant_u8 uint8; | |
| 2: variant_u16 uint16; | |
| }; | |
| type U8U16UnionReserved = strict union { | |
| 1: variant_u8 uint8; | |
| 2: reserved; | |
| 3: variant_u16 uint16; | |
| }; | |
| type U8U16Xunion = flexible union { | |
| 1: variant_u8 uint8; | |
| 2: variant_u16 uint16; | |
| }; | |
| // Mostly copied from sdk/fidl/fuchsia.bluetooth.bredr/service.fidl | |
| const MAX_SEQUENCE_LENGTH uint8 = 255; | |
| const MAX_STRING_LENGTH uint16 = 1024; | |
| type DataElement = strict union { | |
| 1: int8 int8; | |
| 2: int16 int16; | |
| 3: int32 int32; | |
| 4: int64 int64; | |
| 5: uint8 uint8; | |
| 6: uint16 uint16; | |
| 7: uint32 uint32; | |
| 8: uint64 uint64; | |
| 9: str string:MAX_STRING_LENGTH; | |
| 10: b bool; | |
| 11: sequence vector<DataElement:optional>:MAX_SEQUENCE_LENGTH; | |
| 12: alternatives vector<DataElement:optional>:MAX_SEQUENCE_LENGTH; | |
| }; | |
| type U8U16UnionStructType = struct { | |
| u U8U16Union; | |
| }; | |
| type DefaultEnum = strict enum { | |
| X = 23; | |
| }; | |
| type I8Enum = strict enum : int8 { | |
| X = -23; | |
| }; | |
| type I16Enum = strict enum : int16 { | |
| X = -23; | |
| }; | |
| type I32Enum = strict enum : int32 { | |
| X = -23; | |
| }; | |
| type I64Enum = strict enum : int64 { | |
| X = -23; | |
| }; | |
| type DefaultBits = strict bits { | |
| A = 1; | |
| B = 2; | |
| C = 4; | |
| D = 8; | |
| }; | |
| type I8Bits = strict bits : uint8 { | |
| A = 1; | |
| B = 2; | |
| C = 4; | |
| D = 8; | |
| }; | |
| type I16Bits = strict bits : uint16 { | |
| A = 0x100; | |
| B = 0x200; | |
| C = 0x400; | |
| D = 0x800; | |
| }; | |
| type I32Bits = strict bits : uint64 { | |
| A = 0x10000; | |
| B = 0x20000; | |
| C = 0x40000; | |
| D = 0x80000; | |
| }; | |
| type I64Bits = strict bits : uint64 { | |
| A = 0x100000000; | |
| B = 0x200000000; | |
| C = 0x400000000; | |
| D = 0x800000000; | |
| }; | |
| type ValueTable = table { | |
| 1: first_int16 int16; | |
| 2: second_struct TwoStringStruct; | |
| 3: reserved; | |
| 4: third_union IntStructUnion; | |
| }; | |
| type HandleStruct = resource struct { | |
| h1 zx.Handle:CHANNEL; | |
| h2 zx.Handle:CHANNEL; | |
| h3 zx.Handle:CHANNEL; | |
| }; | |
| type OptHandleStruct = resource struct { | |
| sh1 zx.Handle:<CHANNEL, optional>; | |
| sh2 zx.Handle:<CHANNEL, optional>; | |
| }; | |
| type HandleTable = resource table { | |
| 1: h1 zx.Handle:CHANNEL; | |
| 2: s1 OptHandleStruct; | |
| }; | |
| type TraversalOrder = resource struct { | |
| s box<OptHandleStruct>; | |
| h1 zx.Handle:<CHANNEL, optional>; | |
| h2 zx.Handle:<CHANNEL, optional>; | |
| }; | |
| type TraversalStruct = resource struct { | |
| a uint32; | |
| b zx.Handle:<CHANNEL, optional>; | |
| }; | |
| type TraversalMain = resource struct { | |
| x uint32; | |
| y box<TraversalStruct>; | |
| }; | |
| closed protocol ParamProtocol { | |
| strict Method(); | |
| }; |