| // 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. |
| // |
| // Code generated by tools/fidl/gidl-conformance-suite/regen.sh; DO NOT EDIT. |
| // WARNING: This file is machine generated by fidlgen. |
| |
| library fidl_conformance_async; |
| |
| import 'dart:async' as $async; |
| import 'dart:core' hide Set; |
| import 'dart:developer'; |
| import 'dart:typed_data'; |
| |
| import 'package:fidl/fidl.dart' as $fidl; |
| import 'package:meta/meta.dart'; |
| import 'package:zircon/zircon.dart' as $zx; |
| |
| // ignore_for_file: always_specify_types |
| // ignore_for_file: avoid_positional_boolean_parameters |
| // ignore_for_file: avoid_returning_null |
| // ignore_for_file: cascade_invocations |
| // ignore_for_file: constant_identifier_names |
| // ignore_for_file: one_member_abstracts |
| // ignore_for_file: prefer_constructors_over_static_methods |
| // ignore_for_file: prefer_single_quotes |
| // ignore_for_file: public_member_api_docs |
| // ignore_for_file: unused_import |
| // ignore_for_file: unused_local_variable |
| // ignore_for_file: non_constant_identifier_names |
| // ignore_for_file: library_prefixes |
| // ignore_for_file: prefer_typing_uninitialized_variables |
| // ignore_for_file: avoid_js_rounded_ints |
| // ignore_for_file: unnecessary_parenthesis |
| // ignore_for_file: always_put_required_named_parameters_first |
| // ignore_for_file: prefer_generic_function_type_aliases |
| // ignore_for_file: prefer_equal_for_default_values |
| // ignore_for_file: avoid_catches_without_on_clauses |
| // ignore_for_file: unused_shown_name |
| // ignore_for_file: unnecessary_lambdas |
| // ignore_for_file: comment_references |
| // ignore_for_file: avoid_unused_constructor_parameters |
| |
| class EnumUint32 extends $fidl.Enum { |
| factory EnumUint32(int _v) { |
| switch (_v) { |
| case 0x3231302f: |
| return member; |
| default: |
| return null; |
| } |
| } |
| static const EnumUint32 member = EnumUint32._(0x3231302f); |
| |
| const EnumUint32._(this.$value); |
| |
| @override |
| final int $value; |
| |
| static const Map<String, EnumUint32> $valuesMap = { |
| r'member': member, |
| }; |
| |
| static const List<EnumUint32> $values = [ |
| member, |
| ]; |
| |
| // TODO: remove, see: FIDL-587 |
| static const List<EnumUint32> values = EnumUint32.$values; |
| |
| static EnumUint32 $valueOf(String name) => $valuesMap[name]; |
| |
| @override |
| String toString() { |
| switch ($value) { |
| case 0x3231302f: |
| return r'EnumUint32.member'; |
| default: |
| return null; |
| } |
| } |
| |
| static EnumUint32 _ctor(int v) => EnumUint32(v); |
| } |
| |
| const $fidl.EnumType<EnumUint32> kEnumUint32_Type = $fidl.EnumType<EnumUint32>( |
| type: $fidl.Uint32Type(), ctor: EnumUint32._ctor); |
| |
| class EnumUint8 extends $fidl.Enum { |
| factory EnumUint8(int _v) { |
| switch (_v) { |
| case 0x8: |
| return member; |
| default: |
| return null; |
| } |
| } |
| static const EnumUint8 member = EnumUint8._(0x8); |
| |
| const EnumUint8._(this.$value); |
| |
| @override |
| final int $value; |
| |
| static const Map<String, EnumUint8> $valuesMap = { |
| r'member': member, |
| }; |
| |
| static const List<EnumUint8> $values = [ |
| member, |
| ]; |
| |
| // TODO: remove, see: FIDL-587 |
| static const List<EnumUint8> values = EnumUint8.$values; |
| |
| static EnumUint8 $valueOf(String name) => $valuesMap[name]; |
| |
| @override |
| String toString() { |
| switch ($value) { |
| case 0x8: |
| return r'EnumUint8.member'; |
| default: |
| return null; |
| } |
| } |
| |
| static EnumUint8 _ctor(int v) => EnumUint8(v); |
| } |
| |
| const $fidl.EnumType<EnumUint8> kEnumUint8_Type = |
| $fidl.EnumType<EnumUint8>(type: $fidl.Uint8Type(), ctor: EnumUint8._ctor); |
| |
| class BitsUint32 extends $fidl.Bits { |
| static const BitsUint32 memberLow1 = BitsUint32._(0x1); |
| static const BitsUint32 memberLow2 = BitsUint32._(0x2); |
| static const BitsUint32 memberHig1 = BitsUint32._(0x10000000); |
| static const BitsUint32 memberHig2 = BitsUint32._(0x20000000); |
| static const BitsUint32 $none = BitsUint32._(0); |
| |
| const BitsUint32._(this.$value); |
| |
| BitsUint32 operator |(BitsUint32 other) { |
| return BitsUint32._($value | other.$value); |
| } |
| |
| BitsUint32 operator &(BitsUint32 other) { |
| return BitsUint32._($value & other.$value); |
| } |
| |
| @override |
| final int $value; |
| |
| @override |
| String toString() { |
| if ($value == null) { |
| return null; |
| } |
| List<String> parts = []; |
| if ($value & 0x1 != 0) { |
| parts.add(r'BitsUint32.memberLow1'); |
| } |
| if ($value & 0x2 != 0) { |
| parts.add(r'BitsUint32.memberLow2'); |
| } |
| if ($value & 0x10000000 != 0) { |
| parts.add(r'BitsUint32.memberHig1'); |
| } |
| if ($value & 0x20000000 != 0) { |
| parts.add(r'BitsUint32.memberHig2'); |
| } |
| if (parts.isEmpty) { |
| return r'BitsUint32.$none'; |
| } else { |
| return parts.join(" | "); |
| } |
| } |
| |
| static BitsUint32 _ctor(int v) => BitsUint32._(v); |
| } |
| |
| const $fidl.BitsType<BitsUint32> kBitsUint32_Type = $fidl.BitsType<BitsUint32>( |
| type: $fidl.Uint32Type(), ctor: BitsUint32._ctor); |
| |
| class BitsUint8 extends $fidl.Bits { |
| static const BitsUint8 member = BitsUint8._(0x8); |
| static const BitsUint8 $none = BitsUint8._(0); |
| |
| const BitsUint8._(this.$value); |
| |
| BitsUint8 operator |(BitsUint8 other) { |
| return BitsUint8._($value | other.$value); |
| } |
| |
| BitsUint8 operator &(BitsUint8 other) { |
| return BitsUint8._($value & other.$value); |
| } |
| |
| @override |
| final int $value; |
| |
| @override |
| String toString() { |
| if ($value == null) { |
| return null; |
| } |
| List<String> parts = []; |
| if ($value & 0x8 != 0) { |
| parts.add(r'BitsUint8.member'); |
| } |
| if (parts.isEmpty) { |
| return r'BitsUint8.$none'; |
| } else { |
| return parts.join(" | "); |
| } |
| } |
| |
| static BitsUint8 _ctor(int v) => BitsUint8._(v); |
| } |
| |
| const $fidl.BitsType<BitsUint8> kBitsUint8_Type = |
| $fidl.BitsType<BitsUint8>(type: $fidl.Uint8Type(), ctor: BitsUint8._ctor); |
| |
| enum IpAddressConfigTag { |
| paddingSize24Align4, // 0x1 |
| dhcp, // 0x2 |
| } |
| |
| const Map<int, IpAddressConfigTag> _IpAddressConfigTag_map = { |
| 1: IpAddressConfigTag.paddingSize24Align4, |
| 2: IpAddressConfigTag.dhcp, |
| }; |
| |
| class IpAddressConfig extends $fidl.XUnion { |
| const IpAddressConfig.withPaddingSize24Align4(Uint32List value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const IpAddressConfig.withDhcp(bool value) |
| : _ordinal = 2, |
| _data = value; |
| |
| IpAddressConfig._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| IpAddressConfigTag get $tag => _IpAddressConfigTag_map[_ordinal]; |
| |
| Uint32List get paddingSize24Align4 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| bool get dhcp { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'IpAddressConfig.paddingSize24Align4($paddingSize24Align4)'; |
| case 2: |
| return 'IpAddressConfig.dhcp($dhcp)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static IpAddressConfig _ctor(int ordinal, Object data) { |
| return IpAddressConfig._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<IpAddressConfig> kIpAddressConfig_Type = |
| $fidl.XUnionType<IpAddressConfig>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.ArrayType<Uint32List>( |
| element: $fidl.Uint32Type(), elementCount: 6), |
| 2: $fidl.BoolType(), |
| }, |
| ctor: IpAddressConfig._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<IpAddressConfig> kIpAddressConfig_OptType = |
| $fidl.XUnionType<IpAddressConfig>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.ArrayType<Uint32List>( |
| element: $fidl.Uint32Type(), elementCount: 6), |
| 2: $fidl.BoolType(), |
| }, |
| ctor: IpAddressConfig._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionWithBoundStringTag { |
| boundFiveStr, // 0x1 |
| } |
| |
| const Map<int, UnionWithBoundStringTag> _UnionWithBoundStringTag_map = { |
| 1: UnionWithBoundStringTag.boundFiveStr, |
| }; |
| |
| class UnionWithBoundString extends $fidl.XUnion { |
| const UnionWithBoundString.withBoundFiveStr(String value) |
| : _ordinal = 1, |
| _data = value; |
| |
| UnionWithBoundString._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionWithBoundStringTag get $tag => _UnionWithBoundStringTag_map[_ordinal]; |
| |
| String get boundFiveStr { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionWithBoundString.boundFiveStr($boundFiveStr)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionWithBoundString _ctor(int ordinal, Object data) { |
| return UnionWithBoundString._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithBoundString> kUnionWithBoundString_Type = |
| $fidl.XUnionType<UnionWithBoundString>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: 5, nullable: false), |
| }, |
| ctor: UnionWithBoundString._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithBoundString> kUnionWithBoundString_OptType = |
| $fidl.XUnionType<UnionWithBoundString>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: 5, nullable: false), |
| }, |
| ctor: UnionWithBoundString._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum SingleVariantUnionTag { |
| x, // 0x1 |
| } |
| |
| const Map<int, SingleVariantUnionTag> _SingleVariantUnionTag_map = { |
| 1: SingleVariantUnionTag.x, |
| }; |
| |
| class SingleVariantUnion extends $fidl.XUnion { |
| const SingleVariantUnion.withX(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| SingleVariantUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| SingleVariantUnionTag get $tag => _SingleVariantUnionTag_map[_ordinal]; |
| |
| int get x { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'SingleVariantUnion.x($x)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static SingleVariantUnion _ctor(int ordinal, Object data) { |
| return SingleVariantUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SingleVariantUnion> kSingleVariantUnion_Type = |
| $fidl.XUnionType<SingleVariantUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint32Type(), |
| }, |
| ctor: SingleVariantUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SingleVariantUnion> kSingleVariantUnion_OptType = |
| $fidl.XUnionType<SingleVariantUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint32Type(), |
| }, |
| ctor: SingleVariantUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum ReverseOrdinalUnionTag { |
| z, // 0x1 |
| y, // 0x2 |
| x, // 0x4 |
| } |
| |
| const Map<int, ReverseOrdinalUnionTag> _ReverseOrdinalUnionTag_map = { |
| 1: ReverseOrdinalUnionTag.z, |
| 2: ReverseOrdinalUnionTag.y, |
| 4: ReverseOrdinalUnionTag.x, |
| }; |
| |
| class ReverseOrdinalUnion extends $fidl.XUnion { |
| const ReverseOrdinalUnion.withZ(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const ReverseOrdinalUnion.withY(bool value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const ReverseOrdinalUnion.withX(int value) |
| : _ordinal = 4, |
| _data = value; |
| |
| ReverseOrdinalUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| ReverseOrdinalUnionTag get $tag => _ReverseOrdinalUnionTag_map[_ordinal]; |
| |
| int get z { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| bool get y { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get x { |
| if (_ordinal != 4) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'ReverseOrdinalUnion.z($z)'; |
| case 2: |
| return 'ReverseOrdinalUnion.y($y)'; |
| case 4: |
| return 'ReverseOrdinalUnion.x($x)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static ReverseOrdinalUnion _ctor(int ordinal, Object data) { |
| return ReverseOrdinalUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<ReverseOrdinalUnion> kReverseOrdinalUnion_Type = |
| $fidl.XUnionType<ReverseOrdinalUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint32Type(), |
| 2: $fidl.BoolType(), |
| 4: $fidl.Int64Type(), |
| }, |
| ctor: ReverseOrdinalUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<ReverseOrdinalUnion> kReverseOrdinalUnion_OptType = |
| $fidl.XUnionType<ReverseOrdinalUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint32Type(), |
| 2: $fidl.BoolType(), |
| 4: $fidl.Int64Type(), |
| }, |
| ctor: ReverseOrdinalUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionWithEmptyStructTag { |
| s, // 0x1 |
| forceAlignmentOf8, // 0x2 |
| } |
| |
| const Map<int, UnionWithEmptyStructTag> _UnionWithEmptyStructTag_map = { |
| 1: UnionWithEmptyStructTag.s, |
| 2: UnionWithEmptyStructTag.forceAlignmentOf8, |
| }; |
| |
| class UnionWithEmptyStruct extends $fidl.XUnion { |
| const UnionWithEmptyStruct.withS(EmptyStruct value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionWithEmptyStruct.withForceAlignmentOf8(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| UnionWithEmptyStruct._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionWithEmptyStructTag get $tag => _UnionWithEmptyStructTag_map[_ordinal]; |
| |
| EmptyStruct get s { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get forceAlignmentOf8 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionWithEmptyStruct.s($s)'; |
| case 2: |
| return 'UnionWithEmptyStruct.forceAlignmentOf8($forceAlignmentOf8)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionWithEmptyStruct _ctor(int ordinal, Object data) { |
| return UnionWithEmptyStruct._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithEmptyStruct> kUnionWithEmptyStruct_Type = |
| $fidl.XUnionType<UnionWithEmptyStruct>( |
| members: <int, $fidl.FidlType>{ |
| 1: kEmptyStruct_Type, |
| 2: $fidl.Uint64Type(), |
| }, |
| ctor: UnionWithEmptyStruct._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithEmptyStruct> kUnionWithEmptyStruct_OptType = |
| $fidl.XUnionType<UnionWithEmptyStruct>( |
| members: <int, $fidl.FidlType>{ |
| 1: kEmptyStruct_Type, |
| 2: $fidl.Uint64Type(), |
| }, |
| ctor: UnionWithEmptyStruct._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionSize8Align4Tag { |
| unused1, // 0x1 |
| unused2, // 0x2 |
| variant, // 0x3 |
| } |
| |
| const Map<int, UnionSize8Align4Tag> _UnionSize8Align4Tag_map = { |
| 1: UnionSize8Align4Tag.unused1, |
| 2: UnionSize8Align4Tag.unused2, |
| 3: UnionSize8Align4Tag.variant, |
| }; |
| |
| class UnionSize8Align4 extends $fidl.XUnion { |
| const UnionSize8Align4.withUnused1(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionSize8Align4.withUnused2(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const UnionSize8Align4.withVariant(int value) |
| : _ordinal = 3, |
| _data = value; |
| |
| UnionSize8Align4._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionSize8Align4Tag get $tag => _UnionSize8Align4Tag_map[_ordinal]; |
| |
| int get unused1 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused2 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get variant { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionSize8Align4.unused1($unused1)'; |
| case 2: |
| return 'UnionSize8Align4.unused2($unused2)'; |
| case 3: |
| return 'UnionSize8Align4.variant($variant)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionSize8Align4 _ctor(int ordinal, Object data) { |
| return UnionSize8Align4._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize8Align4> kUnionSize8Align4_Type = |
| $fidl.XUnionType<UnionSize8Align4>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint32Type(), |
| }, |
| ctor: UnionSize8Align4._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize8Align4> kUnionSize8Align4_OptType = |
| $fidl.XUnionType<UnionSize8Align4>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint32Type(), |
| }, |
| ctor: UnionSize8Align4._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionSize12Align4Tag { |
| unused1, // 0x1 |
| unused2, // 0x2 |
| unused3, // 0x3 |
| variant, // 0x4 |
| } |
| |
| const Map<int, UnionSize12Align4Tag> _UnionSize12Align4Tag_map = { |
| 1: UnionSize12Align4Tag.unused1, |
| 2: UnionSize12Align4Tag.unused2, |
| 3: UnionSize12Align4Tag.unused3, |
| 4: UnionSize12Align4Tag.variant, |
| }; |
| |
| class UnionSize12Align4 extends $fidl.XUnion { |
| const UnionSize12Align4.withUnused1(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionSize12Align4.withUnused2(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const UnionSize12Align4.withUnused3(int value) |
| : _ordinal = 3, |
| _data = value; |
| |
| const UnionSize12Align4.withVariant(Uint8List value) |
| : _ordinal = 4, |
| _data = value; |
| |
| UnionSize12Align4._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionSize12Align4Tag get $tag => _UnionSize12Align4Tag_map[_ordinal]; |
| |
| int get unused1 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused2 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused3 { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| Uint8List get variant { |
| if (_ordinal != 4) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionSize12Align4.unused1($unused1)'; |
| case 2: |
| return 'UnionSize12Align4.unused2($unused2)'; |
| case 3: |
| return 'UnionSize12Align4.unused3($unused3)'; |
| case 4: |
| return 'UnionSize12Align4.variant($variant)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionSize12Align4 _ctor(int ordinal, Object data) { |
| return UnionSize12Align4._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize12Align4> kUnionSize12Align4_Type = |
| $fidl.XUnionType<UnionSize12Align4>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| 4: $fidl.ArrayType<Uint8List>(element: $fidl.Uint8Type(), elementCount: 6), |
| }, |
| ctor: UnionSize12Align4._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize12Align4> kUnionSize12Align4_OptType = |
| $fidl.XUnionType<UnionSize12Align4>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| 4: $fidl.ArrayType<Uint8List>(element: $fidl.Uint8Type(), elementCount: 6), |
| }, |
| ctor: UnionSize12Align4._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionSize24Align8Tag { |
| unused1, // 0x1 |
| unused2, // 0x2 |
| unused3, // 0x3 |
| variant, // 0x4 |
| } |
| |
| const Map<int, UnionSize24Align8Tag> _UnionSize24Align8Tag_map = { |
| 1: UnionSize24Align8Tag.unused1, |
| 2: UnionSize24Align8Tag.unused2, |
| 3: UnionSize24Align8Tag.unused3, |
| 4: UnionSize24Align8Tag.variant, |
| }; |
| |
| class UnionSize24Align8 extends $fidl.XUnion { |
| const UnionSize24Align8.withUnused1(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionSize24Align8.withUnused2(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const UnionSize24Align8.withUnused3(int value) |
| : _ordinal = 3, |
| _data = value; |
| |
| const UnionSize24Align8.withVariant(StructSize16Align8 value) |
| : _ordinal = 4, |
| _data = value; |
| |
| UnionSize24Align8._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionSize24Align8Tag get $tag => _UnionSize24Align8Tag_map[_ordinal]; |
| |
| int get unused1 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused2 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused3 { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| StructSize16Align8 get variant { |
| if (_ordinal != 4) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionSize24Align8.unused1($unused1)'; |
| case 2: |
| return 'UnionSize24Align8.unused2($unused2)'; |
| case 3: |
| return 'UnionSize24Align8.unused3($unused3)'; |
| case 4: |
| return 'UnionSize24Align8.variant($variant)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionSize24Align8 _ctor(int ordinal, Object data) { |
| return UnionSize24Align8._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize24Align8> kUnionSize24Align8_Type = |
| $fidl.XUnionType<UnionSize24Align8>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| 4: kStructSize16Align8_Type, |
| }, |
| ctor: UnionSize24Align8._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize24Align8> kUnionSize24Align8_OptType = |
| $fidl.XUnionType<UnionSize24Align8>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| 4: kStructSize16Align8_Type, |
| }, |
| ctor: UnionSize24Align8._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionSize36Align4Tag { |
| unused1, // 0x1 |
| unused2, // 0x2 |
| unused3, // 0x3 |
| variant, // 0x4 |
| } |
| |
| const Map<int, UnionSize36Align4Tag> _UnionSize36Align4Tag_map = { |
| 1: UnionSize36Align4Tag.unused1, |
| 2: UnionSize36Align4Tag.unused2, |
| 3: UnionSize36Align4Tag.unused3, |
| 4: UnionSize36Align4Tag.variant, |
| }; |
| |
| class UnionSize36Align4 extends $fidl.XUnion { |
| const UnionSize36Align4.withUnused1(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionSize36Align4.withUnused2(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const UnionSize36Align4.withUnused3(int value) |
| : _ordinal = 3, |
| _data = value; |
| |
| const UnionSize36Align4.withVariant(Uint8List value) |
| : _ordinal = 4, |
| _data = value; |
| |
| UnionSize36Align4._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionSize36Align4Tag get $tag => _UnionSize36Align4Tag_map[_ordinal]; |
| |
| int get unused1 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused2 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused3 { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| Uint8List get variant { |
| if (_ordinal != 4) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionSize36Align4.unused1($unused1)'; |
| case 2: |
| return 'UnionSize36Align4.unused2($unused2)'; |
| case 3: |
| return 'UnionSize36Align4.unused3($unused3)'; |
| case 4: |
| return 'UnionSize36Align4.variant($variant)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionSize36Align4 _ctor(int ordinal, Object data) { |
| return UnionSize36Align4._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize36Align4> kUnionSize36Align4_Type = |
| $fidl.XUnionType<UnionSize36Align4>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| 4: $fidl.ArrayType<Uint8List>(element: $fidl.Uint8Type(), elementCount: 32), |
| }, |
| ctor: UnionSize36Align4._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionSize36Align4> kUnionSize36Align4_OptType = |
| $fidl.XUnionType<UnionSize36Align4>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| 4: $fidl.ArrayType<Uint8List>(element: $fidl.Uint8Type(), elementCount: 32), |
| }, |
| ctor: UnionSize36Align4._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionOfUnionTag { |
| unused1, // 0x1 |
| size8align4, // 0x2 |
| size12align4, // 0x3 |
| unused2, // 0x4 |
| size24align8, // 0x5 |
| } |
| |
| const Map<int, UnionOfUnionTag> _UnionOfUnionTag_map = { |
| 1: UnionOfUnionTag.unused1, |
| 2: UnionOfUnionTag.size8align4, |
| 3: UnionOfUnionTag.size12align4, |
| 4: UnionOfUnionTag.unused2, |
| 5: UnionOfUnionTag.size24align8, |
| }; |
| |
| class UnionOfUnion extends $fidl.XUnion { |
| const UnionOfUnion.withUnused1(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionOfUnion.withSize8align4(UnionSize8Align4 value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const UnionOfUnion.withSize12align4(UnionSize12Align4 value) |
| : _ordinal = 3, |
| _data = value; |
| |
| const UnionOfUnion.withUnused2(int value) |
| : _ordinal = 4, |
| _data = value; |
| |
| const UnionOfUnion.withSize24align8(UnionSize24Align8 value) |
| : _ordinal = 5, |
| _data = value; |
| |
| UnionOfUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionOfUnionTag get $tag => _UnionOfUnionTag_map[_ordinal]; |
| |
| int get unused1 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| UnionSize8Align4 get size8align4 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| UnionSize12Align4 get size12align4 { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused2 { |
| if (_ordinal != 4) { |
| return null; |
| } |
| return _data; |
| } |
| |
| UnionSize24Align8 get size24align8 { |
| if (_ordinal != 5) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionOfUnion.unused1($unused1)'; |
| case 2: |
| return 'UnionOfUnion.size8align4($size8align4)'; |
| case 3: |
| return 'UnionOfUnion.size12align4($size12align4)'; |
| case 4: |
| return 'UnionOfUnion.unused2($unused2)'; |
| case 5: |
| return 'UnionOfUnion.size24align8($size24align8)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionOfUnion _ctor(int ordinal, Object data) { |
| return UnionOfUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionOfUnion> kUnionOfUnion_Type = |
| $fidl.XUnionType<UnionOfUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: kUnionSize8Align4_Type, |
| 3: kUnionSize12Align4_Type, |
| 4: $fidl.Uint8Type(), |
| 5: kUnionSize24Align8_Type, |
| }, |
| ctor: UnionOfUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionOfUnion> kUnionOfUnion_OptType = |
| $fidl.XUnionType<UnionOfUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: kUnionSize8Align4_Type, |
| 3: kUnionSize12Align4_Type, |
| 4: $fidl.Uint8Type(), |
| 5: kUnionSize24Align8_Type, |
| }, |
| ctor: UnionOfUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionWithVectorTag { |
| unused, // 0x1 |
| vectorOfUint8, // 0x2 |
| s, // 0x3 |
| vectorS3A1, // 0x4 |
| vectorS3A2, // 0x5 |
| handles, // 0x6 |
| arrayS3A1, // 0x7 |
| arrayS3A2, // 0x8 |
| vectorUnion, // 0x9 |
| } |
| |
| const Map<int, UnionWithVectorTag> _UnionWithVectorTag_map = { |
| 1: UnionWithVectorTag.unused, |
| 2: UnionWithVectorTag.vectorOfUint8, |
| 3: UnionWithVectorTag.s, |
| 4: UnionWithVectorTag.vectorS3A1, |
| 5: UnionWithVectorTag.vectorS3A2, |
| 6: UnionWithVectorTag.handles, |
| 7: UnionWithVectorTag.arrayS3A1, |
| 8: UnionWithVectorTag.arrayS3A2, |
| 9: UnionWithVectorTag.vectorUnion, |
| }; |
| |
| class UnionWithVector extends $fidl.XUnion { |
| const UnionWithVector.withUnused(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionWithVector.withVectorOfUint8(Uint8List value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const UnionWithVector.withS(String value) |
| : _ordinal = 3, |
| _data = value; |
| |
| const UnionWithVector.withVectorS3A1(List<StructSize3Align1> value) |
| : _ordinal = 4, |
| _data = value; |
| |
| const UnionWithVector.withVectorS3A2(List<StructSize3Align2> value) |
| : _ordinal = 5, |
| _data = value; |
| |
| const UnionWithVector.withHandles(Uint32List value) |
| : _ordinal = 6, |
| _data = value; |
| |
| const UnionWithVector.withArrayS3A1(List<StructSize3Align1> value) |
| : _ordinal = 7, |
| _data = value; |
| |
| const UnionWithVector.withArrayS3A2(List<StructSize3Align2> value) |
| : _ordinal = 8, |
| _data = value; |
| |
| const UnionWithVector.withVectorUnion(List<UnionSize8Align4> value) |
| : _ordinal = 9, |
| _data = value; |
| |
| UnionWithVector._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionWithVectorTag get $tag => _UnionWithVectorTag_map[_ordinal]; |
| |
| int get unused { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| Uint8List get vectorOfUint8 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| String get s { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| List<StructSize3Align1> get vectorS3A1 { |
| if (_ordinal != 4) { |
| return null; |
| } |
| return _data; |
| } |
| |
| List<StructSize3Align2> get vectorS3A2 { |
| if (_ordinal != 5) { |
| return null; |
| } |
| return _data; |
| } |
| |
| Uint32List get handles { |
| if (_ordinal != 6) { |
| return null; |
| } |
| return _data; |
| } |
| |
| List<StructSize3Align1> get arrayS3A1 { |
| if (_ordinal != 7) { |
| return null; |
| } |
| return _data; |
| } |
| |
| List<StructSize3Align2> get arrayS3A2 { |
| if (_ordinal != 8) { |
| return null; |
| } |
| return _data; |
| } |
| |
| List<UnionSize8Align4> get vectorUnion { |
| if (_ordinal != 9) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionWithVector.unused($unused)'; |
| case 2: |
| return 'UnionWithVector.vectorOfUint8($vectorOfUint8)'; |
| case 3: |
| return 'UnionWithVector.s($s)'; |
| case 4: |
| return 'UnionWithVector.vectorS3A1($vectorS3A1)'; |
| case 5: |
| return 'UnionWithVector.vectorS3A2($vectorS3A2)'; |
| case 6: |
| return 'UnionWithVector.handles($handles)'; |
| case 7: |
| return 'UnionWithVector.arrayS3A1($arrayS3A1)'; |
| case 8: |
| return 'UnionWithVector.arrayS3A2($arrayS3A2)'; |
| case 9: |
| return 'UnionWithVector.vectorUnion($vectorUnion)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionWithVector _ctor(int ordinal, Object data) { |
| return UnionWithVector._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithVector> kUnionWithVector_Type = |
| $fidl.XUnionType<UnionWithVector>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.VectorType<Uint8List>( |
| element: $fidl.Uint8Type(), maybeElementCount: null, nullable: false), |
| 3: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 4: $fidl.VectorType<List<StructSize3Align1>>( |
| element: kStructSize3Align1_Type, |
| maybeElementCount: null, |
| nullable: false), |
| 5: $fidl.VectorType<List<StructSize3Align2>>( |
| element: kStructSize3Align2_Type, |
| maybeElementCount: null, |
| nullable: false), |
| 6: $fidl.VectorType<Uint32List>( |
| element: $fidl.Uint32Type(), maybeElementCount: null, nullable: false), |
| 7: $fidl.ArrayType<List<StructSize3Align1>>( |
| element: kStructSize3Align1_Type, elementCount: 2), |
| 8: $fidl.ArrayType<List<StructSize3Align2>>( |
| element: kStructSize3Align2_Type, elementCount: 2), |
| 9: $fidl.VectorType<List<UnionSize8Align4>>( |
| element: kUnionSize8Align4_Type, |
| maybeElementCount: null, |
| nullable: false), |
| }, |
| ctor: UnionWithVector._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithVector> kUnionWithVector_OptType = |
| $fidl.XUnionType<UnionWithVector>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.VectorType<Uint8List>( |
| element: $fidl.Uint8Type(), maybeElementCount: null, nullable: false), |
| 3: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 4: $fidl.VectorType<List<StructSize3Align1>>( |
| element: kStructSize3Align1_Type, |
| maybeElementCount: null, |
| nullable: false), |
| 5: $fidl.VectorType<List<StructSize3Align2>>( |
| element: kStructSize3Align2_Type, |
| maybeElementCount: null, |
| nullable: false), |
| 6: $fidl.VectorType<Uint32List>( |
| element: $fidl.Uint32Type(), maybeElementCount: null, nullable: false), |
| 7: $fidl.ArrayType<List<StructSize3Align1>>( |
| element: kStructSize3Align1_Type, elementCount: 2), |
| 8: $fidl.ArrayType<List<StructSize3Align2>>( |
| element: kStructSize3Align2_Type, elementCount: 2), |
| 9: $fidl.VectorType<List<UnionSize8Align4>>( |
| element: kUnionSize8Align4_Type, |
| maybeElementCount: null, |
| nullable: false), |
| }, |
| ctor: UnionWithVector._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum StringUnionTag { |
| unused, // 0x1 |
| s, // 0x2 |
| u8, // 0x3 |
| } |
| |
| const Map<int, StringUnionTag> _StringUnionTag_map = { |
| 1: StringUnionTag.unused, |
| 2: StringUnionTag.s, |
| 3: StringUnionTag.u8, |
| }; |
| |
| class StringUnion extends $fidl.XUnion { |
| const StringUnion.withUnused(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const StringUnion.withS(String value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const StringUnion.withU8(int value) |
| : _ordinal = 3, |
| _data = value; |
| |
| StringUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| StringUnionTag get $tag => _StringUnionTag_map[_ordinal]; |
| |
| int get unused { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| String get s { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get u8 { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'StringUnion.unused($unused)'; |
| case 2: |
| return 'StringUnion.s($s)'; |
| case 3: |
| return 'StringUnion.u8($u8)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static StringUnion _ctor(int ordinal, Object data) { |
| return StringUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<StringUnion> kStringUnion_Type = |
| $fidl.XUnionType<StringUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 3: $fidl.Uint8Type(), |
| }, |
| ctor: StringUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<StringUnion> kStringUnion_OptType = |
| $fidl.XUnionType<StringUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 3: $fidl.Uint8Type(), |
| }, |
| ctor: StringUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum EmptyStructUnionTag { |
| unused, // 0x1 |
| es, // 0x2 |
| } |
| |
| const Map<int, EmptyStructUnionTag> _EmptyStructUnionTag_map = { |
| 1: EmptyStructUnionTag.unused, |
| 2: EmptyStructUnionTag.es, |
| }; |
| |
| class EmptyStructUnion extends $fidl.XUnion { |
| const EmptyStructUnion.withUnused(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const EmptyStructUnion.withEs(TransformerEmptyStruct value) |
| : _ordinal = 2, |
| _data = value; |
| |
| EmptyStructUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| EmptyStructUnionTag get $tag => _EmptyStructUnionTag_map[_ordinal]; |
| |
| int get unused { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| TransformerEmptyStruct get es { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'EmptyStructUnion.unused($unused)'; |
| case 2: |
| return 'EmptyStructUnion.es($es)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static EmptyStructUnion _ctor(int ordinal, Object data) { |
| return EmptyStructUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<EmptyStructUnion> kEmptyStructUnion_Type = |
| $fidl.XUnionType<EmptyStructUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: kTransformerEmptyStruct_Type, |
| }, |
| ctor: EmptyStructUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<EmptyStructUnion> kEmptyStructUnion_OptType = |
| $fidl.XUnionType<EmptyStructUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: kTransformerEmptyStruct_Type, |
| }, |
| ctor: EmptyStructUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionAtTheBottomTag { |
| unused1, // 0x1 |
| unused2, // 0x2 |
| tiny, // 0x3 |
| } |
| |
| const Map<int, UnionAtTheBottomTag> _UnionAtTheBottomTag_map = { |
| 1: UnionAtTheBottomTag.unused1, |
| 2: UnionAtTheBottomTag.unused2, |
| 3: UnionAtTheBottomTag.tiny, |
| }; |
| |
| class UnionAtTheBottom extends $fidl.XUnion { |
| const UnionAtTheBottom.withUnused1(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionAtTheBottom.withUnused2(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const UnionAtTheBottom.withTiny(int value) |
| : _ordinal = 3, |
| _data = value; |
| |
| UnionAtTheBottom._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionAtTheBottomTag get $tag => _UnionAtTheBottomTag_map[_ordinal]; |
| |
| int get unused1 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get unused2 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get tiny { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionAtTheBottom.unused1($unused1)'; |
| case 2: |
| return 'UnionAtTheBottom.unused2($unused2)'; |
| case 3: |
| return 'UnionAtTheBottom.tiny($tiny)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionAtTheBottom _ctor(int ordinal, Object data) { |
| return UnionAtTheBottom._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionAtTheBottom> kUnionAtTheBottom_Type = |
| $fidl.XUnionType<UnionAtTheBottom>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| }, |
| ctor: UnionAtTheBottom._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionAtTheBottom> kUnionAtTheBottom_OptType = |
| $fidl.XUnionType<UnionAtTheBottom>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 2: $fidl.Uint8Type(), |
| 3: $fidl.Uint8Type(), |
| }, |
| ctor: UnionAtTheBottom._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionOfXUnionThenTableThenXUnionThenUnionTag { |
| unused1, // 0x1 |
| variant, // 0x3 |
| } |
| |
| const Map<int, UnionOfXUnionThenTableThenXUnionThenUnionTag> |
| _UnionOfXUnionThenTableThenXUnionThenUnionTag_map = { |
| 1: UnionOfXUnionThenTableThenXUnionThenUnionTag.unused1, |
| 3: UnionOfXUnionThenTableThenXUnionThenUnionTag.variant, |
| }; |
| |
| class UnionOfXUnionThenTableThenXUnionThenUnion extends $fidl.XUnion { |
| const UnionOfXUnionThenTableThenXUnionThenUnion.withUnused1(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionOfXUnionThenTableThenXUnionThenUnion.withVariant( |
| XUnionOfTableThenXUnionThenUnion value) |
| : _ordinal = 3, |
| _data = value; |
| |
| UnionOfXUnionThenTableThenXUnionThenUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionOfXUnionThenTableThenXUnionThenUnionTag get $tag => |
| _UnionOfXUnionThenTableThenXUnionThenUnionTag_map[_ordinal]; |
| |
| int get unused1 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| XUnionOfTableThenXUnionThenUnion get variant { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionOfXUnionThenTableThenXUnionThenUnion.unused1($unused1)'; |
| case 3: |
| return 'UnionOfXUnionThenTableThenXUnionThenUnion.variant($variant)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionOfXUnionThenTableThenXUnionThenUnion _ctor( |
| int ordinal, Object data) { |
| return UnionOfXUnionThenTableThenXUnionThenUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionOfXUnionThenTableThenXUnionThenUnion> |
| kUnionOfXUnionThenTableThenXUnionThenUnion_Type = |
| $fidl.XUnionType<UnionOfXUnionThenTableThenXUnionThenUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 3: kXUnionOfTableThenXUnionThenUnion_Type, |
| }, |
| ctor: UnionOfXUnionThenTableThenXUnionThenUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionOfXUnionThenTableThenXUnionThenUnion> |
| kUnionOfXUnionThenTableThenXUnionThenUnion_OptType = |
| $fidl.XUnionType<UnionOfXUnionThenTableThenXUnionThenUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 3: kXUnionOfTableThenXUnionThenUnion_Type, |
| }, |
| ctor: UnionOfXUnionThenTableThenXUnionThenUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum StringBoolUnionTag { |
| s, // 0x1 |
| b, // 0x2 |
| } |
| |
| const Map<int, StringBoolUnionTag> _StringBoolUnionTag_map = { |
| 1: StringBoolUnionTag.s, |
| 2: StringBoolUnionTag.b, |
| }; |
| |
| class StringBoolUnion extends $fidl.XUnion { |
| const StringBoolUnion.withS(String value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const StringBoolUnion.withB(bool value) |
| : _ordinal = 2, |
| _data = value; |
| |
| StringBoolUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| StringBoolUnionTag get $tag => _StringBoolUnionTag_map[_ordinal]; |
| |
| String get s { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| bool get b { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'StringBoolUnion.s($s)'; |
| case 2: |
| return 'StringBoolUnion.b($b)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static StringBoolUnion _ctor(int ordinal, Object data) { |
| return StringBoolUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<StringBoolUnion> kStringBoolUnion_Type = |
| $fidl.XUnionType<StringBoolUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 2: $fidl.BoolType(), |
| }, |
| ctor: StringBoolUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<StringBoolUnion> kStringBoolUnion_OptType = |
| $fidl.XUnionType<StringBoolUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 2: $fidl.BoolType(), |
| }, |
| ctor: StringBoolUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum Regression9ResultTag { |
| ok, // 0x1 |
| error, // 0x2 |
| } |
| |
| const Map<int, Regression9ResultTag> _Regression9ResultTag_map = { |
| 1: Regression9ResultTag.ok, |
| 2: Regression9ResultTag.error, |
| }; |
| |
| class Regression9Result extends $fidl.XUnion { |
| const Regression9Result.withOk(Regression9Value value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const Regression9Result.withError(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| Regression9Result._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| Regression9ResultTag get $tag => _Regression9ResultTag_map[_ordinal]; |
| |
| Regression9Value get ok { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get error { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'Regression9Result.ok($ok)'; |
| case 2: |
| return 'Regression9Result.error($error)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static Regression9Result _ctor(int ordinal, Object data) { |
| return Regression9Result._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<Regression9Result> kRegression9Result_Type = |
| $fidl.XUnionType<Regression9Result>( |
| members: <int, $fidl.FidlType>{ |
| 1: kRegression9Value_Type, |
| 2: $fidl.Uint32Type(), |
| }, |
| ctor: Regression9Result._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<Regression9Result> kRegression9Result_OptType = |
| $fidl.XUnionType<Regression9Result>( |
| members: <int, $fidl.FidlType>{ |
| 1: kRegression9Value_Type, |
| 2: $fidl.Uint32Type(), |
| }, |
| ctor: Regression9Result._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionWithRegression10TableTag { |
| unused, // 0x1 |
| atV2, // 0x3 |
| } |
| |
| const Map<int, UnionWithRegression10TableTag> |
| _UnionWithRegression10TableTag_map = { |
| 1: UnionWithRegression10TableTag.unused, |
| 3: UnionWithRegression10TableTag.atV2, |
| }; |
| |
| class UnionWithRegression10Table extends $fidl.XUnion { |
| const UnionWithRegression10Table.withUnused(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const UnionWithRegression10Table.withAtV2(Regression10TableV2 value) |
| : _ordinal = 3, |
| _data = value; |
| |
| UnionWithRegression10Table._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionWithRegression10TableTag get $tag => |
| _UnionWithRegression10TableTag_map[_ordinal]; |
| |
| int get unused { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| Regression10TableV2 get atV2 { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionWithRegression10Table.unused($unused)'; |
| case 3: |
| return 'UnionWithRegression10Table.atV2($atV2)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionWithRegression10Table _ctor(int ordinal, Object data) { |
| return UnionWithRegression10Table._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithRegression10Table> |
| kUnionWithRegression10Table_Type = |
| $fidl.XUnionType<UnionWithRegression10Table>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 3: kRegression10TableV2_Type, |
| }, |
| ctor: UnionWithRegression10Table._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithRegression10Table> |
| kUnionWithRegression10Table_OptType = |
| $fidl.XUnionType<UnionWithRegression10Table>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 3: kRegression10TableV2_Type, |
| }, |
| ctor: UnionWithRegression10Table._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum UnionWithVectorOfVectorsTag { |
| v, // 0x1 |
| } |
| |
| const Map<int, UnionWithVectorOfVectorsTag> _UnionWithVectorOfVectorsTag_map = { |
| 1: UnionWithVectorOfVectorsTag.v, |
| }; |
| |
| class UnionWithVectorOfVectors extends $fidl.XUnion { |
| const UnionWithVectorOfVectors.withV(List<List<StructSize3Align1>> value) |
| : _ordinal = 1, |
| _data = value; |
| |
| UnionWithVectorOfVectors._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| UnionWithVectorOfVectorsTag get $tag => |
| _UnionWithVectorOfVectorsTag_map[_ordinal]; |
| |
| List<List<StructSize3Align1>> get v { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'UnionWithVectorOfVectors.v($v)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static UnionWithVectorOfVectors _ctor(int ordinal, Object data) { |
| return UnionWithVectorOfVectors._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithVectorOfVectors> |
| kUnionWithVectorOfVectors_Type = $fidl.XUnionType<UnionWithVectorOfVectors>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.VectorType<List<List<StructSize3Align1>>>( |
| element: $fidl.VectorType<List<StructSize3Align1>>( |
| element: $fidl.PointerType<StructSize3Align1>( |
| element: kStructSize3Align1_Type), |
| maybeElementCount: null, |
| nullable: false), |
| maybeElementCount: null, |
| nullable: false), |
| }, |
| ctor: UnionWithVectorOfVectors._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<UnionWithVectorOfVectors> |
| kUnionWithVectorOfVectors_OptType = |
| $fidl.XUnionType<UnionWithVectorOfVectors>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.VectorType<List<List<StructSize3Align1>>>( |
| element: $fidl.VectorType<List<StructSize3Align1>>( |
| element: $fidl.PointerType<StructSize3Align1>( |
| element: kStructSize3Align1_Type), |
| maybeElementCount: null, |
| nullable: false), |
| maybeElementCount: null, |
| nullable: false), |
| }, |
| ctor: UnionWithVectorOfVectors._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum CompatUnionTag { |
| s, // 0x1 |
| b, // 0x2 |
| } |
| |
| const Map<int, CompatUnionTag> _CompatUnionTag_map = { |
| 1: CompatUnionTag.s, |
| 2: CompatUnionTag.b, |
| }; |
| |
| class CompatUnion extends $fidl.XUnion { |
| const CompatUnion.withS(String value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const CompatUnion.withB(bool value) |
| : _ordinal = 2, |
| _data = value; |
| |
| CompatUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| CompatUnionTag get $tag => _CompatUnionTag_map[_ordinal]; |
| |
| String get s { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| bool get b { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'CompatUnion.s($s)'; |
| case 2: |
| return 'CompatUnion.b($b)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static CompatUnion _ctor(int ordinal, Object data) { |
| return CompatUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<CompatUnion> kCompatUnion_Type = |
| $fidl.XUnionType<CompatUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 2: $fidl.BoolType(), |
| }, |
| ctor: CompatUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<CompatUnion> kCompatUnion_OptType = |
| $fidl.XUnionType<CompatUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 2: $fidl.BoolType(), |
| }, |
| ctor: CompatUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum SimpleUnionTag { |
| i32, // 0x1 |
| i64, // 0x2 |
| s, // 0x3 |
| str, // 0x4 |
| } |
| |
| const Map<int, SimpleUnionTag> _SimpleUnionTag_map = { |
| 1: SimpleUnionTag.i32, |
| 2: SimpleUnionTag.i64, |
| 3: SimpleUnionTag.s, |
| 4: SimpleUnionTag.str, |
| }; |
| |
| class SimpleUnion extends $fidl.XUnion { |
| const SimpleUnion.withI32(int value) |
| : _ordinal = 1, |
| _data = value; |
| |
| const SimpleUnion.withI64(int value) |
| : _ordinal = 2, |
| _data = value; |
| |
| const SimpleUnion.withS(Int64Struct value) |
| : _ordinal = 3, |
| _data = value; |
| |
| const SimpleUnion.withStr(String value) |
| : _ordinal = 4, |
| _data = value; |
| |
| SimpleUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| SimpleUnionTag get $tag => _SimpleUnionTag_map[_ordinal]; |
| |
| int get i32 { |
| if (_ordinal != 1) { |
| return null; |
| } |
| return _data; |
| } |
| |
| int get i64 { |
| if (_ordinal != 2) { |
| return null; |
| } |
| return _data; |
| } |
| |
| Int64Struct get s { |
| if (_ordinal != 3) { |
| return null; |
| } |
| return _data; |
| } |
| |
| String get str { |
| if (_ordinal != 4) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1: |
| return 'SimpleUnion.i32($i32)'; |
| case 2: |
| return 'SimpleUnion.i64($i64)'; |
| case 3: |
| return 'SimpleUnion.s($s)'; |
| case 4: |
| return 'SimpleUnion.str($str)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static SimpleUnion _ctor(int ordinal, Object data) { |
| return SimpleUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SimpleUnion> kSimpleUnion_Type = |
| $fidl.XUnionType<SimpleUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Int32Type(), |
| 2: $fidl.Int64Type(), |
| 3: kInt64Struct_Type, |
| 4: $fidl.StringType(maybeElementCount: null, nullable: false), |
| }, |
| ctor: SimpleUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SimpleUnion> kSimpleUnion_OptType = |
| $fidl.XUnionType<SimpleUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Int32Type(), |
| 2: $fidl.Int64Type(), |
| 3: kInt64Struct_Type, |
| 4: $fidl.StringType(maybeElementCount: null, nullable: false), |
| }, |
| ctor: SimpleUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| enum XUnionWithEmptyStructTag { |
| $unknown, |
| s, // 0x7499e0fe |
| } |
| |
| const Map<int, XUnionWithEmptyStructTag> _XUnionWithEmptyStructTag_map = { |
| 1956241662: XUnionWithEmptyStructTag.s, |
| }; |
| |
| class XUnionWithEmptyStruct extends $fidl.XUnion { |
| const XUnionWithEmptyStruct.withS(EmptyStruct value) |
| : _ordinal = 1956241662, |
| _data = value; |
| |
| XUnionWithEmptyStruct._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| XUnionWithEmptyStructTag get $tag { |
| final XUnionWithEmptyStructTag $rawtag = |
| _XUnionWithEmptyStructTag_map[_ordinal]; |
| return $rawtag == null ? XUnionWithEmptyStructTag.$unknown : $rawtag; |
| } |
| |
| EmptyStruct get s { |
| if (_ordinal != 1956241662) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1956241662: |
| return 'XUnionWithEmptyStruct.s($s)'; |
| default: |
| return 'XUnionWithEmptyStruct.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static XUnionWithEmptyStruct _ctor(int ordinal, Object data) { |
| return XUnionWithEmptyStruct._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithEmptyStruct> kXUnionWithEmptyStruct_Type = |
| $fidl.XUnionType<XUnionWithEmptyStruct>( |
| members: <int, $fidl.FidlType>{ |
| 1956241662: kEmptyStruct_Type, |
| }, |
| ctor: XUnionWithEmptyStruct._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithEmptyStruct> kXUnionWithEmptyStruct_OptType = |
| $fidl.XUnionType<XUnionWithEmptyStruct>( |
| members: <int, $fidl.FidlType>{ |
| 1956241662: kEmptyStruct_Type, |
| }, |
| ctor: XUnionWithEmptyStruct._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum XUnionWithStructTag { |
| $unknown, |
| s, // 0x193e5c14 |
| } |
| |
| const Map<int, XUnionWithStructTag> _XUnionWithStructTag_map = { |
| 423517204: XUnionWithStructTag.s, |
| }; |
| |
| class XUnionWithStruct extends $fidl.XUnion { |
| const XUnionWithStruct.withS(StructSize3Align1 value) |
| : _ordinal = 423517204, |
| _data = value; |
| |
| XUnionWithStruct._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| XUnionWithStructTag get $tag { |
| final XUnionWithStructTag $rawtag = _XUnionWithStructTag_map[_ordinal]; |
| return $rawtag == null ? XUnionWithStructTag.$unknown : $rawtag; |
| } |
| |
| StructSize3Align1 get s { |
| if (_ordinal != 423517204) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 423517204: |
| return 'XUnionWithStruct.s($s)'; |
| default: |
| return 'XUnionWithStruct.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static XUnionWithStruct _ctor(int ordinal, Object data) { |
| return XUnionWithStruct._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithStruct> kXUnionWithStruct_Type = |
| $fidl.XUnionType<XUnionWithStruct>( |
| members: <int, $fidl.FidlType>{ |
| 423517204: kStructSize3Align1_Type, |
| }, |
| ctor: XUnionWithStruct._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithStruct> kXUnionWithStruct_OptType = |
| $fidl.XUnionType<XUnionWithStruct>( |
| members: <int, $fidl.FidlType>{ |
| 423517204: kStructSize3Align1_Type, |
| }, |
| ctor: XUnionWithStruct._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum XUnionWithXUnionTag { |
| $unknown, |
| xu, // 0x6c06691f |
| } |
| |
| const Map<int, XUnionWithXUnionTag> _XUnionWithXUnionTag_map = { |
| 1812359455: XUnionWithXUnionTag.xu, |
| }; |
| |
| class XUnionWithXUnion extends $fidl.XUnion { |
| const XUnionWithXUnion.withXu(XUnionWithStruct value) |
| : _ordinal = 1812359455, |
| _data = value; |
| |
| XUnionWithXUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| XUnionWithXUnionTag get $tag { |
| final XUnionWithXUnionTag $rawtag = _XUnionWithXUnionTag_map[_ordinal]; |
| return $rawtag == null ? XUnionWithXUnionTag.$unknown : $rawtag; |
| } |
| |
| XUnionWithStruct get xu { |
| if (_ordinal != 1812359455) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1812359455: |
| return 'XUnionWithXUnion.xu($xu)'; |
| default: |
| return 'XUnionWithXUnion.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static XUnionWithXUnion _ctor(int ordinal, Object data) { |
| return XUnionWithXUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithXUnion> kXUnionWithXUnion_Type = |
| $fidl.XUnionType<XUnionWithXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1812359455: kXUnionWithStruct_Type, |
| }, |
| ctor: XUnionWithXUnion._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithXUnion> kXUnionWithXUnion_OptType = |
| $fidl.XUnionType<XUnionWithXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1812359455: kXUnionWithStruct_Type, |
| }, |
| ctor: XUnionWithXUnion._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum XUnionWithUnionsTag { |
| $unknown, |
| u1, // 0x28c52917 |
| u2, // 0x75862b98 |
| } |
| |
| const Map<int, XUnionWithUnionsTag> _XUnionWithUnionsTag_map = { |
| 684009751: XUnionWithUnionsTag.u1, |
| 1971727256: XUnionWithUnionsTag.u2, |
| }; |
| |
| class XUnionWithUnions extends $fidl.XUnion { |
| const XUnionWithUnions.withU1(UnionSize8Align4 value) |
| : _ordinal = 684009751, |
| _data = value; |
| |
| const XUnionWithUnions.withU2(UnionSize12Align4 value) |
| : _ordinal = 1971727256, |
| _data = value; |
| |
| XUnionWithUnions._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| XUnionWithUnionsTag get $tag { |
| final XUnionWithUnionsTag $rawtag = _XUnionWithUnionsTag_map[_ordinal]; |
| return $rawtag == null ? XUnionWithUnionsTag.$unknown : $rawtag; |
| } |
| |
| UnionSize8Align4 get u1 { |
| if (_ordinal != 684009751) { |
| return null; |
| } |
| return _data; |
| } |
| |
| UnionSize12Align4 get u2 { |
| if (_ordinal != 1971727256) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 684009751: |
| return 'XUnionWithUnions.u1($u1)'; |
| case 1971727256: |
| return 'XUnionWithUnions.u2($u2)'; |
| default: |
| return 'XUnionWithUnions.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static XUnionWithUnions _ctor(int ordinal, Object data) { |
| return XUnionWithUnions._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithUnions> kXUnionWithUnions_Type = |
| $fidl.XUnionType<XUnionWithUnions>( |
| members: <int, $fidl.FidlType>{ |
| 684009751: kUnionSize8Align4_Type, |
| 1971727256: kUnionSize12Align4_Type, |
| }, |
| ctor: XUnionWithUnions._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionWithUnions> kXUnionWithUnions_OptType = |
| $fidl.XUnionType<XUnionWithUnions>( |
| members: <int, $fidl.FidlType>{ |
| 684009751: kUnionSize8Align4_Type, |
| 1971727256: kUnionSize12Align4_Type, |
| }, |
| ctor: XUnionWithUnions._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum XUnionOfUnionTag { |
| $unknown, |
| variant, // 0x38220594 |
| } |
| |
| const Map<int, XUnionOfUnionTag> _XUnionOfUnionTag_map = { |
| 941753748: XUnionOfUnionTag.variant, |
| }; |
| |
| class XUnionOfUnion extends $fidl.XUnion { |
| const XUnionOfUnion.withVariant(UnionAtTheBottom value) |
| : _ordinal = 941753748, |
| _data = value; |
| |
| XUnionOfUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| XUnionOfUnionTag get $tag { |
| final XUnionOfUnionTag $rawtag = _XUnionOfUnionTag_map[_ordinal]; |
| return $rawtag == null ? XUnionOfUnionTag.$unknown : $rawtag; |
| } |
| |
| UnionAtTheBottom get variant { |
| if (_ordinal != 941753748) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 941753748: |
| return 'XUnionOfUnion.variant($variant)'; |
| default: |
| return 'XUnionOfUnion.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static XUnionOfUnion _ctor(int ordinal, Object data) { |
| return XUnionOfUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionOfUnion> kXUnionOfUnion_Type = |
| $fidl.XUnionType<XUnionOfUnion>( |
| members: <int, $fidl.FidlType>{ |
| 941753748: kUnionAtTheBottom_Type, |
| }, |
| ctor: XUnionOfUnion._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionOfUnion> kXUnionOfUnion_OptType = |
| $fidl.XUnionType<XUnionOfUnion>( |
| members: <int, $fidl.FidlType>{ |
| 941753748: kUnionAtTheBottom_Type, |
| }, |
| ctor: XUnionOfUnion._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum XUnionOfTableThenXUnionThenUnionTag { |
| $unknown, |
| variant, // 0x22b8614e |
| } |
| |
| const Map<int, XUnionOfTableThenXUnionThenUnionTag> |
| _XUnionOfTableThenXUnionThenUnionTag_map = { |
| 582508878: XUnionOfTableThenXUnionThenUnionTag.variant, |
| }; |
| |
| class XUnionOfTableThenXUnionThenUnion extends $fidl.XUnion { |
| const XUnionOfTableThenXUnionThenUnion.withVariant( |
| TableOfXUnionThenUnion value) |
| : _ordinal = 582508878, |
| _data = value; |
| |
| XUnionOfTableThenXUnionThenUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| XUnionOfTableThenXUnionThenUnionTag get $tag { |
| final XUnionOfTableThenXUnionThenUnionTag $rawtag = |
| _XUnionOfTableThenXUnionThenUnionTag_map[_ordinal]; |
| return $rawtag == null |
| ? XUnionOfTableThenXUnionThenUnionTag.$unknown |
| : $rawtag; |
| } |
| |
| TableOfXUnionThenUnion get variant { |
| if (_ordinal != 582508878) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 582508878: |
| return 'XUnionOfTableThenXUnionThenUnion.variant($variant)'; |
| default: |
| return 'XUnionOfTableThenXUnionThenUnion.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static XUnionOfTableThenXUnionThenUnion _ctor(int ordinal, Object data) { |
| return XUnionOfTableThenXUnionThenUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionOfTableThenXUnionThenUnion> |
| kXUnionOfTableThenXUnionThenUnion_Type = |
| $fidl.XUnionType<XUnionOfTableThenXUnionThenUnion>( |
| members: <int, $fidl.FidlType>{ |
| 582508878: kTableOfXUnionThenUnion_Type, |
| }, |
| ctor: XUnionOfTableThenXUnionThenUnion._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<XUnionOfTableThenXUnionThenUnion> |
| kXUnionOfTableThenXUnionThenUnion_OptType = |
| $fidl.XUnionType<XUnionOfTableThenXUnionThenUnion>( |
| members: <int, $fidl.FidlType>{ |
| 582508878: kTableOfXUnionThenUnion_Type, |
| }, |
| ctor: XUnionOfTableThenXUnionThenUnion._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum CompatXUnionTag { |
| $unknown, |
| s, // 0x5af8efa8 |
| b, // 0x536bc590 |
| } |
| |
| const Map<int, CompatXUnionTag> _CompatXUnionTag_map = { |
| 1526263720: CompatXUnionTag.s, |
| 1399571856: CompatXUnionTag.b, |
| }; |
| |
| class CompatXUnion extends $fidl.XUnion { |
| const CompatXUnion.withS(String value) |
| : _ordinal = 1526263720, |
| _data = value; |
| |
| const CompatXUnion.withB(bool value) |
| : _ordinal = 1399571856, |
| _data = value; |
| |
| CompatXUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| CompatXUnionTag get $tag { |
| final CompatXUnionTag $rawtag = _CompatXUnionTag_map[_ordinal]; |
| return $rawtag == null ? CompatXUnionTag.$unknown : $rawtag; |
| } |
| |
| String get s { |
| if (_ordinal != 1526263720) { |
| return null; |
| } |
| return _data; |
| } |
| |
| bool get b { |
| if (_ordinal != 1399571856) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 1526263720: |
| return 'CompatXUnion.s($s)'; |
| case 1399571856: |
| return 'CompatXUnion.b($b)'; |
| default: |
| return 'CompatXUnion.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static CompatXUnion _ctor(int ordinal, Object data) { |
| return CompatXUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<CompatXUnion> kCompatXUnion_Type = |
| $fidl.XUnionType<CompatXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1526263720: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 1399571856: $fidl.BoolType(), |
| }, |
| ctor: CompatXUnion._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<CompatXUnion> kCompatXUnion_OptType = |
| $fidl.XUnionType<CompatXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 1526263720: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 1399571856: $fidl.BoolType(), |
| }, |
| ctor: CompatXUnion._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum SampleXUnionTag { |
| $unknown, |
| u, // 0x389c56b2 |
| su, // 0x792f4f1d |
| st, // 0x21de8d5 |
| } |
| |
| const Map<int, SampleXUnionTag> _SampleXUnionTag_map = { |
| 949769906: SampleXUnionTag.u, |
| 2033143581: SampleXUnionTag.su, |
| 35514581: SampleXUnionTag.st, |
| }; |
| |
| class SampleXUnion extends $fidl.XUnion { |
| const SampleXUnion.withU(int value) |
| : _ordinal = 949769906, |
| _data = value; |
| |
| const SampleXUnion.withSu(SimpleUnion value) |
| : _ordinal = 2033143581, |
| _data = value; |
| |
| const SampleXUnion.withSt(SimpleTable value) |
| : _ordinal = 35514581, |
| _data = value; |
| |
| SampleXUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| SampleXUnionTag get $tag { |
| final SampleXUnionTag $rawtag = _SampleXUnionTag_map[_ordinal]; |
| return $rawtag == null ? SampleXUnionTag.$unknown : $rawtag; |
| } |
| |
| int get u { |
| if (_ordinal != 949769906) { |
| return null; |
| } |
| return _data; |
| } |
| |
| SimpleUnion get su { |
| if (_ordinal != 2033143581) { |
| return null; |
| } |
| return _data; |
| } |
| |
| SimpleTable get st { |
| if (_ordinal != 35514581) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 949769906: |
| return 'SampleXUnion.u($u)'; |
| case 2033143581: |
| return 'SampleXUnion.su($su)'; |
| case 35514581: |
| return 'SampleXUnion.st($st)'; |
| default: |
| return 'SampleXUnion.<UNKNOWN>'; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static SampleXUnion _ctor(int ordinal, Object data) { |
| return SampleXUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SampleXUnion> kSampleXUnion_Type = |
| $fidl.XUnionType<SampleXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 949769906: $fidl.Uint32Type(), |
| 2033143581: kSimpleUnion_Type, |
| 35514581: kSimpleTable_Type, |
| }, |
| ctor: SampleXUnion._ctor, |
| nullable: false, |
| flexible: true, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SampleXUnion> kSampleXUnion_OptType = |
| $fidl.XUnionType<SampleXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 949769906: $fidl.Uint32Type(), |
| 2033143581: kSimpleUnion_Type, |
| 35514581: kSimpleTable_Type, |
| }, |
| ctor: SampleXUnion._ctor, |
| nullable: true, |
| flexible: true, |
| ); |
| |
| enum SampleStrictXUnionTag { |
| u, // 0x8e2ea72 |
| su, // 0x27f3a73b |
| st, // 0x372354ef |
| } |
| |
| const Map<int, SampleStrictXUnionTag> _SampleStrictXUnionTag_map = { |
| 149088882: SampleStrictXUnionTag.u, |
| 670279483: SampleStrictXUnionTag.su, |
| 925062383: SampleStrictXUnionTag.st, |
| }; |
| |
| class SampleStrictXUnion extends $fidl.XUnion { |
| const SampleStrictXUnion.withU(int value) |
| : _ordinal = 149088882, |
| _data = value; |
| |
| const SampleStrictXUnion.withSu(SimpleUnion value) |
| : _ordinal = 670279483, |
| _data = value; |
| |
| const SampleStrictXUnion.withSt(SimpleTable value) |
| : _ordinal = 925062383, |
| _data = value; |
| |
| SampleStrictXUnion._(int ordinal, Object data) |
| : _ordinal = ordinal, |
| _data = data; |
| |
| final int _ordinal; |
| final _data; |
| |
| SampleStrictXUnionTag get $tag => _SampleStrictXUnionTag_map[_ordinal]; |
| |
| int get u { |
| if (_ordinal != 149088882) { |
| return null; |
| } |
| return _data; |
| } |
| |
| SimpleUnion get su { |
| if (_ordinal != 670279483) { |
| return null; |
| } |
| return _data; |
| } |
| |
| SimpleTable get st { |
| if (_ordinal != 925062383) { |
| return null; |
| } |
| return _data; |
| } |
| |
| @override |
| String toString() { |
| switch (_ordinal) { |
| case 149088882: |
| return 'SampleStrictXUnion.u($u)'; |
| case 670279483: |
| return 'SampleStrictXUnion.su($su)'; |
| case 925062383: |
| return 'SampleStrictXUnion.st($st)'; |
| default: |
| return null; |
| } |
| } |
| |
| @override |
| int get $ordinal => _ordinal; |
| |
| @override |
| Object get $data => _data; |
| |
| static SampleStrictXUnion _ctor(int ordinal, Object data) { |
| return SampleStrictXUnion._(ordinal, data); |
| } |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SampleStrictXUnion> kSampleStrictXUnion_Type = |
| $fidl.XUnionType<SampleStrictXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 149088882: $fidl.Uint32Type(), |
| 670279483: kSimpleUnion_Type, |
| 925062383: kSimpleTable_Type, |
| }, |
| ctor: SampleStrictXUnion._ctor, |
| nullable: false, |
| flexible: false, |
| ); |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.XUnionType<SampleStrictXUnion> kSampleStrictXUnion_OptType = |
| $fidl.XUnionType<SampleStrictXUnion>( |
| members: <int, $fidl.FidlType>{ |
| 149088882: $fidl.Uint32Type(), |
| 670279483: kSimpleUnion_Type, |
| 925062383: kSimpleTable_Type, |
| }, |
| ctor: SampleStrictXUnion._ctor, |
| nullable: true, |
| flexible: false, |
| ); |
| |
| class TestXUnionInTable extends $fidl.Struct { |
| const TestXUnionInTable({ |
| @required this.value, |
| }); |
| TestXUnionInTable.clone( |
| TestXUnionInTable $orig, { |
| XUnionInTable value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| TestXUnionInTable._(List<Object> argv) : value = argv[0]; |
| final XUnionInTable value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TestXUnionInTable' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static TestXUnionInTable _ctor(List<Object> argv) => |
| TestXUnionInTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TestXUnionInTable> kTestXUnionInTable_Type = |
| $fidl.StructType<TestXUnionInTable>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<XUnionInTable>( |
| type: kXUnionInTable_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: TestXUnionInTable._ctor, |
| ); |
| |
| class InterfaceConfig extends $fidl.Struct { |
| const InterfaceConfig({ |
| @required this.name, |
| @required this.ipAddressConfig, |
| }); |
| InterfaceConfig.clone( |
| InterfaceConfig $orig, { |
| String name, |
| IpAddressConfig ipAddressConfig, |
| }) : this( |
| name: name ?? $orig.name, |
| ipAddressConfig: ipAddressConfig ?? $orig.ipAddressConfig, |
| ); |
| |
| InterfaceConfig._(List<Object> argv) |
| : name = argv[0], |
| ipAddressConfig = argv[1]; |
| final String name; |
| final IpAddressConfig ipAddressConfig; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| name, |
| ipAddressConfig, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'InterfaceConfig' r'(name: ' + |
| name.toString() + |
| r', ipAddressConfig: ' + |
| ipAddressConfig.toString() + |
| r')'; |
| } |
| |
| static InterfaceConfig _ctor(List<Object> argv) => InterfaceConfig._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<InterfaceConfig> kInterfaceConfig_Type = |
| $fidl.StructType<InterfaceConfig>( |
| inlineSizeOld: 48, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<IpAddressConfig>( |
| type: kIpAddressConfig_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: InterfaceConfig._ctor, |
| ); |
| |
| class TestAddEthernetDeviceRequest extends $fidl.Struct { |
| const TestAddEthernetDeviceRequest({ |
| @required this.topologicalPath, |
| @required this.config, |
| @required this.thisShouldBeAHandle, |
| }); |
| TestAddEthernetDeviceRequest.clone( |
| TestAddEthernetDeviceRequest $orig, { |
| String topologicalPath, |
| InterfaceConfig config, |
| int thisShouldBeAHandle, |
| }) : this( |
| topologicalPath: topologicalPath ?? $orig.topologicalPath, |
| config: config ?? $orig.config, |
| thisShouldBeAHandle: thisShouldBeAHandle ?? $orig.thisShouldBeAHandle, |
| ); |
| |
| TestAddEthernetDeviceRequest._(List<Object> argv) |
| : topologicalPath = argv[0], |
| config = argv[1], |
| thisShouldBeAHandle = argv[2]; |
| final String topologicalPath; |
| final InterfaceConfig config; |
| final int thisShouldBeAHandle; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| topologicalPath, |
| config, |
| thisShouldBeAHandle, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TestAddEthernetDeviceRequest' r'(topologicalPath: ' + |
| topologicalPath.toString() + |
| r', config: ' + |
| config.toString() + |
| r', thisShouldBeAHandle: ' + |
| thisShouldBeAHandle.toString() + |
| r')'; |
| } |
| |
| static TestAddEthernetDeviceRequest _ctor(List<Object> argv) => |
| TestAddEthernetDeviceRequest._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TestAddEthernetDeviceRequest> |
| kTestAddEthernetDeviceRequest_Type = |
| $fidl.StructType<TestAddEthernetDeviceRequest>( |
| inlineSizeOld: 72, |
| inlineSizeV1: 64, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<InterfaceConfig>( |
| type: kInterfaceConfig_Type, offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 64, offsetV1: 56), |
| ], |
| ctor: TestAddEthernetDeviceRequest._ctor, |
| ); |
| |
| class NodeAttributes extends $fidl.Struct { |
| const NodeAttributes({ |
| @required this.mode, |
| @required this.id, |
| @required this.contentSize, |
| @required this.storageSize, |
| @required this.linkCount, |
| @required this.creationTime, |
| @required this.modificationTime, |
| }); |
| NodeAttributes.clone( |
| NodeAttributes $orig, { |
| int mode, |
| int id, |
| int contentSize, |
| int storageSize, |
| int linkCount, |
| int creationTime, |
| int modificationTime, |
| }) : this( |
| mode: mode ?? $orig.mode, |
| id: id ?? $orig.id, |
| contentSize: contentSize ?? $orig.contentSize, |
| storageSize: storageSize ?? $orig.storageSize, |
| linkCount: linkCount ?? $orig.linkCount, |
| creationTime: creationTime ?? $orig.creationTime, |
| modificationTime: modificationTime ?? $orig.modificationTime, |
| ); |
| |
| NodeAttributes._(List<Object> argv) |
| : mode = argv[0], |
| id = argv[1], |
| contentSize = argv[2], |
| storageSize = argv[3], |
| linkCount = argv[4], |
| creationTime = argv[5], |
| modificationTime = argv[6]; |
| final int mode; |
| final int id; |
| final int contentSize; |
| final int storageSize; |
| final int linkCount; |
| final int creationTime; |
| final int modificationTime; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| mode, |
| id, |
| contentSize, |
| storageSize, |
| linkCount, |
| creationTime, |
| modificationTime, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'NodeAttributes' r'(mode: ' + |
| mode.toString() + |
| r', id: ' + |
| id.toString() + |
| r', contentSize: ' + |
| contentSize.toString() + |
| r', storageSize: ' + |
| storageSize.toString() + |
| r', linkCount: ' + |
| linkCount.toString() + |
| r', creationTime: ' + |
| creationTime.toString() + |
| r', modificationTime: ' + |
| modificationTime.toString() + |
| r')'; |
| } |
| |
| static NodeAttributes _ctor(List<Object> argv) => NodeAttributes._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<NodeAttributes> kNodeAttributes_Type = |
| $fidl.StructType<NodeAttributes>( |
| inlineSizeOld: 56, |
| inlineSizeV1: 56, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 24, offsetV1: 24), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 32, offsetV1: 32), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 40, offsetV1: 40), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 48, offsetV1: 48), |
| ], |
| ctor: NodeAttributes._ctor, |
| ); |
| |
| class FileGetAttrResponse extends $fidl.Struct { |
| const FileGetAttrResponse({ |
| @required this.s, |
| @required this.attributes, |
| }); |
| FileGetAttrResponse.clone( |
| FileGetAttrResponse $orig, { |
| int s, |
| NodeAttributes attributes, |
| }) : this( |
| s: s ?? $orig.s, |
| attributes: attributes ?? $orig.attributes, |
| ); |
| |
| FileGetAttrResponse._(List<Object> argv) |
| : s = argv[0], |
| attributes = argv[1]; |
| final int s; |
| final NodeAttributes attributes; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| s, |
| attributes, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'FileGetAttrResponse' r'(s: ' + |
| s.toString() + |
| r', attributes: ' + |
| attributes.toString() + |
| r')'; |
| } |
| |
| static FileGetAttrResponse _ctor(List<Object> argv) => |
| FileGetAttrResponse._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<FileGetAttrResponse> kFileGetAttrResponse_Type = |
| $fidl.StructType<FileGetAttrResponse>( |
| inlineSizeOld: 64, |
| inlineSizeV1: 64, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Int32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<NodeAttributes>( |
| type: kNodeAttributes_Type, offsetOld: 8, offsetV1: 8), |
| ], |
| ctor: FileGetAttrResponse._ctor, |
| ); |
| |
| class UnionWithBoundStringStruct extends $fidl.Struct { |
| const UnionWithBoundStringStruct({ |
| @required this.v, |
| }); |
| UnionWithBoundStringStruct.clone( |
| UnionWithBoundStringStruct $orig, { |
| UnionWithBoundString v, |
| }) : this( |
| v: v ?? $orig.v, |
| ); |
| |
| UnionWithBoundStringStruct._(List<Object> argv) : v = argv[0]; |
| final UnionWithBoundString v; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| v, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'UnionWithBoundStringStruct' r'(v: ' + v.toString() + r')'; |
| } |
| |
| static UnionWithBoundStringStruct _ctor(List<Object> argv) => |
| UnionWithBoundStringStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<UnionWithBoundStringStruct> |
| kUnionWithBoundStringStruct_Type = |
| $fidl.StructType<UnionWithBoundStringStruct>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<UnionWithBoundString>( |
| type: kUnionWithBoundString_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: UnionWithBoundStringStruct._ctor, |
| ); |
| |
| class SingleVariantUnionStruct extends $fidl.Struct { |
| const SingleVariantUnionStruct({ |
| @required this.u, |
| }); |
| SingleVariantUnionStruct.clone( |
| SingleVariantUnionStruct $orig, { |
| SingleVariantUnion u, |
| }) : this( |
| u: u ?? $orig.u, |
| ); |
| |
| SingleVariantUnionStruct._(List<Object> argv) : u = argv[0]; |
| final SingleVariantUnion u; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| u, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'SingleVariantUnionStruct' r'(u: ' + u.toString() + r')'; |
| } |
| |
| static SingleVariantUnionStruct _ctor(List<Object> argv) => |
| SingleVariantUnionStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<SingleVariantUnionStruct> |
| kSingleVariantUnionStruct_Type = $fidl.StructType<SingleVariantUnionStruct>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<SingleVariantUnion>( |
| type: kSingleVariantUnion_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: SingleVariantUnionStruct._ctor, |
| ); |
| |
| class ReverseOrdinalUnionStruct extends $fidl.Struct { |
| const ReverseOrdinalUnionStruct({ |
| @required this.u, |
| }); |
| ReverseOrdinalUnionStruct.clone( |
| ReverseOrdinalUnionStruct $orig, { |
| ReverseOrdinalUnion u, |
| }) : this( |
| u: u ?? $orig.u, |
| ); |
| |
| ReverseOrdinalUnionStruct._(List<Object> argv) : u = argv[0]; |
| final ReverseOrdinalUnion u; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| u, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'ReverseOrdinalUnionStruct' r'(u: ' + u.toString() + r')'; |
| } |
| |
| static ReverseOrdinalUnionStruct _ctor(List<Object> argv) => |
| ReverseOrdinalUnionStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<ReverseOrdinalUnionStruct> |
| kReverseOrdinalUnionStruct_Type = |
| $fidl.StructType<ReverseOrdinalUnionStruct>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<ReverseOrdinalUnion>( |
| type: kReverseOrdinalUnion_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: ReverseOrdinalUnionStruct._ctor, |
| ); |
| |
| class StructWithInt extends $fidl.Struct { |
| const StructWithInt({ |
| @required this.x, |
| }); |
| StructWithInt.clone( |
| StructWithInt $orig, { |
| int x, |
| }) : this( |
| x: x ?? $orig.x, |
| ); |
| |
| StructWithInt._(List<Object> argv) : x = argv[0]; |
| final int x; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| x, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructWithInt' r'(x: ' + x.toString() + r')'; |
| } |
| |
| static StructWithInt _ctor(List<Object> argv) => StructWithInt._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructWithInt> kStructWithInt_Type = |
| $fidl.StructType<StructWithInt>( |
| inlineSizeOld: 4, |
| inlineSizeV1: 4, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Int32Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StructWithInt._ctor, |
| ); |
| |
| class StructWithArrays extends $fidl.Struct { |
| const StructWithArrays({ |
| @required this.arrInt, |
| @required this.arrString, |
| @required this.arrNullableString, |
| @required this.arrStruct, |
| @required this.arrNullableStruct, |
| @required this.arrArrInt, |
| }); |
| StructWithArrays.clone( |
| StructWithArrays $orig, { |
| Int32List arrInt, |
| List<String> arrString, |
| List<String> arrNullableString, |
| List<StructWithInt> arrStruct, |
| List<StructWithInt> arrNullableStruct, |
| List<Int32List> arrArrInt, |
| }) : this( |
| arrInt: arrInt ?? $orig.arrInt, |
| arrString: arrString ?? $orig.arrString, |
| arrNullableString: arrNullableString ?? $orig.arrNullableString, |
| arrStruct: arrStruct ?? $orig.arrStruct, |
| arrNullableStruct: arrNullableStruct ?? $orig.arrNullableStruct, |
| arrArrInt: arrArrInt ?? $orig.arrArrInt, |
| ); |
| |
| StructWithArrays._(List<Object> argv) |
| : arrInt = argv[0], |
| arrString = argv[1], |
| arrNullableString = argv[2], |
| arrStruct = argv[3], |
| arrNullableStruct = argv[4], |
| arrArrInt = argv[5]; |
| final Int32List arrInt; |
| final List<String> arrString; |
| final List<String> arrNullableString; |
| final List<StructWithInt> arrStruct; |
| final List<StructWithInt> arrNullableStruct; |
| final List<Int32List> arrArrInt; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| arrInt, |
| arrString, |
| arrNullableString, |
| arrStruct, |
| arrNullableStruct, |
| arrArrInt, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructWithArrays' r'(arrInt: ' + |
| arrInt.toString() + |
| r', arrString: ' + |
| arrString.toString() + |
| r', arrNullableString: ' + |
| arrNullableString.toString() + |
| r', arrStruct: ' + |
| arrStruct.toString() + |
| r', arrNullableStruct: ' + |
| arrNullableStruct.toString() + |
| r', arrArrInt: ' + |
| arrArrInt.toString() + |
| r')'; |
| } |
| |
| static StructWithArrays _ctor(List<Object> argv) => StructWithArrays._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructWithArrays> kStructWithArrays_Type = |
| $fidl.StructType<StructWithArrays>( |
| inlineSizeOld: 120, |
| inlineSizeV1: 120, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Int32List>( |
| type: $fidl.ArrayType<Int32List>( |
| element: $fidl.Int32Type(), elementCount: 2), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<List<String>>( |
| type: $fidl.ArrayType<List<String>>( |
| element: $fidl.StringType(maybeElementCount: null, nullable: false), |
| elementCount: 2), |
| offsetOld: 8, |
| offsetV1: 8), |
| $fidl.MemberType<List<String>>( |
| type: $fidl.ArrayType<List<String>>( |
| element: $fidl.StringType(maybeElementCount: null, nullable: true), |
| elementCount: 2), |
| offsetOld: 40, |
| offsetV1: 40), |
| $fidl.MemberType<List<StructWithInt>>( |
| type: $fidl.ArrayType<List<StructWithInt>>( |
| element: kStructWithInt_Type, elementCount: 2), |
| offsetOld: 72, |
| offsetV1: 72), |
| $fidl.MemberType<List<StructWithInt>>( |
| type: $fidl.ArrayType<List<StructWithInt>>( |
| element: |
| $fidl.PointerType<StructWithInt>(element: kStructWithInt_Type), |
| elementCount: 2), |
| offsetOld: 80, |
| offsetV1: 80), |
| $fidl.MemberType<List<Int32List>>( |
| type: $fidl.ArrayType<List<Int32List>>( |
| element: $fidl.ArrayType<Int32List>( |
| element: $fidl.Int32Type(), elementCount: 3), |
| elementCount: 2), |
| offsetOld: 96, |
| offsetV1: 96), |
| ], |
| ctor: StructWithArrays._ctor, |
| ); |
| |
| class StructWithVectors extends $fidl.Struct { |
| const StructWithVectors({ |
| @required this.vecEmpty, |
| @required this.vecInt, |
| @required this.vecString, |
| @required this.vecNullableString, |
| @required this.vecStruct, |
| @required this.vecNullableStruct, |
| @required this.vecVecInt, |
| }); |
| StructWithVectors.clone( |
| StructWithVectors $orig, { |
| Int32List vecEmpty, |
| Int32List vecInt, |
| List<String> vecString, |
| List<String> vecNullableString, |
| List<StructWithInt> vecStruct, |
| List<StructWithInt> vecNullableStruct, |
| List<Int32List> vecVecInt, |
| }) : this( |
| vecEmpty: vecEmpty ?? $orig.vecEmpty, |
| vecInt: vecInt ?? $orig.vecInt, |
| vecString: vecString ?? $orig.vecString, |
| vecNullableString: vecNullableString ?? $orig.vecNullableString, |
| vecStruct: vecStruct ?? $orig.vecStruct, |
| vecNullableStruct: vecNullableStruct ?? $orig.vecNullableStruct, |
| vecVecInt: vecVecInt ?? $orig.vecVecInt, |
| ); |
| |
| StructWithVectors._(List<Object> argv) |
| : vecEmpty = argv[0], |
| vecInt = argv[1], |
| vecString = argv[2], |
| vecNullableString = argv[3], |
| vecStruct = argv[4], |
| vecNullableStruct = argv[5], |
| vecVecInt = argv[6]; |
| final Int32List vecEmpty; |
| final Int32List vecInt; |
| final List<String> vecString; |
| final List<String> vecNullableString; |
| final List<StructWithInt> vecStruct; |
| final List<StructWithInt> vecNullableStruct; |
| final List<Int32List> vecVecInt; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| vecEmpty, |
| vecInt, |
| vecString, |
| vecNullableString, |
| vecStruct, |
| vecNullableStruct, |
| vecVecInt, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructWithVectors' r'(vecEmpty: ' + |
| vecEmpty.toString() + |
| r', vecInt: ' + |
| vecInt.toString() + |
| r', vecString: ' + |
| vecString.toString() + |
| r', vecNullableString: ' + |
| vecNullableString.toString() + |
| r', vecStruct: ' + |
| vecStruct.toString() + |
| r', vecNullableStruct: ' + |
| vecNullableStruct.toString() + |
| r', vecVecInt: ' + |
| vecVecInt.toString() + |
| r')'; |
| } |
| |
| static StructWithVectors _ctor(List<Object> argv) => |
| StructWithVectors._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructWithVectors> kStructWithVectors_Type = |
| $fidl.StructType<StructWithVectors>( |
| inlineSizeOld: 112, |
| inlineSizeV1: 112, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Int32List>( |
| type: $fidl.VectorType<Int32List>( |
| element: $fidl.Int32Type(), |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<Int32List>( |
| type: $fidl.VectorType<Int32List>( |
| element: $fidl.Int32Type(), |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 16, |
| offsetV1: 16), |
| $fidl.MemberType<List<String>>( |
| type: $fidl.VectorType<List<String>>( |
| element: $fidl.StringType(maybeElementCount: null, nullable: false), |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 32, |
| offsetV1: 32), |
| $fidl.MemberType<List<String>>( |
| type: $fidl.VectorType<List<String>>( |
| element: $fidl.StringType(maybeElementCount: null, nullable: true), |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 48, |
| offsetV1: 48), |
| $fidl.MemberType<List<StructWithInt>>( |
| type: $fidl.VectorType<List<StructWithInt>>( |
| element: kStructWithInt_Type, |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 64, |
| offsetV1: 64), |
| $fidl.MemberType<List<StructWithInt>>( |
| type: $fidl.VectorType<List<StructWithInt>>( |
| element: |
| $fidl.PointerType<StructWithInt>(element: kStructWithInt_Type), |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 80, |
| offsetV1: 80), |
| $fidl.MemberType<List<Int32List>>( |
| type: $fidl.VectorType<List<Int32List>>( |
| element: $fidl.VectorType<Int32List>( |
| element: $fidl.Int32Type(), |
| maybeElementCount: null, |
| nullable: false), |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 96, |
| offsetV1: 96), |
| ], |
| ctor: StructWithVectors._ctor, |
| ); |
| |
| class EmptyStruct extends $fidl.Struct { |
| const EmptyStruct({ |
| this.reserved: 0x0, |
| }); |
| EmptyStruct.clone( |
| EmptyStruct $orig, { |
| int reserved, |
| }) : this( |
| reserved: reserved ?? $orig.reserved, |
| ); |
| |
| EmptyStruct._(List<Object> argv) : reserved = argv[0]; |
| final int reserved; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| reserved, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'EmptyStruct' r'(reserved: ' + reserved.toString() + r')'; |
| } |
| |
| static EmptyStruct _ctor(List<Object> argv) => EmptyStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<EmptyStruct> kEmptyStruct_Type = |
| $fidl.StructType<EmptyStruct>( |
| inlineSizeOld: 1, |
| inlineSizeV1: 1, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: EmptyStruct._ctor, |
| ); |
| |
| class EmptyStructSandwich extends $fidl.Struct { |
| const EmptyStructSandwich({ |
| @required this.before, |
| @required this.es, |
| @required this.after, |
| }); |
| EmptyStructSandwich.clone( |
| EmptyStructSandwich $orig, { |
| String before, |
| EmptyStruct es, |
| String after, |
| }) : this( |
| before: before ?? $orig.before, |
| es: es ?? $orig.es, |
| after: after ?? $orig.after, |
| ); |
| |
| EmptyStructSandwich._(List<Object> argv) |
| : before = argv[0], |
| es = argv[1], |
| after = argv[2]; |
| final String before; |
| final EmptyStruct es; |
| final String after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| es, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'EmptyStructSandwich' r'(before: ' + |
| before.toString() + |
| r', es: ' + |
| es.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static EmptyStructSandwich _ctor(List<Object> argv) => |
| EmptyStructSandwich._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<EmptyStructSandwich> kEmptyStructSandwich_Type = |
| $fidl.StructType<EmptyStructSandwich>( |
| inlineSizeOld: 40, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<EmptyStruct>( |
| type: kEmptyStruct_Type, offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 24, |
| offsetV1: 24), |
| ], |
| ctor: EmptyStructSandwich._ctor, |
| ); |
| |
| class Uint8Uint16Uint32Uint64 extends $fidl.Struct { |
| const Uint8Uint16Uint32Uint64({ |
| @required this.f1, |
| @required this.f2, |
| @required this.f3, |
| @required this.f4, |
| }); |
| Uint8Uint16Uint32Uint64.clone( |
| Uint8Uint16Uint32Uint64 $orig, { |
| int f1, |
| int f2, |
| int f3, |
| int f4, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| f3: f3 ?? $orig.f3, |
| f4: f4 ?? $orig.f4, |
| ); |
| |
| Uint8Uint16Uint32Uint64._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1], |
| f3 = argv[2], |
| f4 = argv[3]; |
| final int f1; |
| final int f2; |
| final int f3; |
| final int f4; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| f3, |
| f4, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Uint8Uint16Uint32Uint64' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r', f3: ' + |
| f3.toString() + |
| r', f4: ' + |
| f4.toString() + |
| r')'; |
| } |
| |
| static Uint8Uint16Uint32Uint64 _ctor(List<Object> argv) => |
| Uint8Uint16Uint32Uint64._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Uint8Uint16Uint32Uint64> kUint8Uint16Uint32Uint64_Type = |
| $fidl.StructType<Uint8Uint16Uint32Uint64>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint16Type(), offsetOld: 2, offsetV1: 2), |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 4, offsetV1: 4), |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 8, offsetV1: 8), |
| ], |
| ctor: Uint8Uint16Uint32Uint64._ctor, |
| ); |
| |
| class Uint64Uint32Uint16Uint8 extends $fidl.Struct { |
| const Uint64Uint32Uint16Uint8({ |
| @required this.f1, |
| @required this.f2, |
| @required this.f3, |
| @required this.f4, |
| }); |
| Uint64Uint32Uint16Uint8.clone( |
| Uint64Uint32Uint16Uint8 $orig, { |
| int f1, |
| int f2, |
| int f3, |
| int f4, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| f3: f3 ?? $orig.f3, |
| f4: f4 ?? $orig.f4, |
| ); |
| |
| Uint64Uint32Uint16Uint8._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1], |
| f3 = argv[2], |
| f4 = argv[3]; |
| final int f1; |
| final int f2; |
| final int f3; |
| final int f4; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| f3, |
| f4, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Uint64Uint32Uint16Uint8' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r', f3: ' + |
| f3.toString() + |
| r', f4: ' + |
| f4.toString() + |
| r')'; |
| } |
| |
| static Uint64Uint32Uint16Uint8 _ctor(List<Object> argv) => |
| Uint64Uint32Uint16Uint8._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Uint64Uint32Uint16Uint8> kUint64Uint32Uint16Uint8_Type = |
| $fidl.StructType<Uint64Uint32Uint16Uint8>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint16Type(), offsetOld: 12, offsetV1: 12), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 14, offsetV1: 14), |
| ], |
| ctor: Uint64Uint32Uint16Uint8._ctor, |
| ); |
| |
| class Length2StringWrapper extends $fidl.Struct { |
| const Length2StringWrapper({ |
| @required this.length2String, |
| }); |
| Length2StringWrapper.clone( |
| Length2StringWrapper $orig, { |
| String length2String, |
| }) : this( |
| length2String: length2String ?? $orig.length2String, |
| ); |
| |
| Length2StringWrapper._(List<Object> argv) : length2String = argv[0]; |
| final String length2String; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| length2String, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Length2StringWrapper' r'(length2String: ' + |
| length2String.toString() + |
| r')'; |
| } |
| |
| static Length2StringWrapper _ctor(List<Object> argv) => |
| Length2StringWrapper._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Length2StringWrapper> kLength2StringWrapper_Type = |
| $fidl.StructType<Length2StringWrapper>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: 2, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Length2StringWrapper._ctor, |
| ); |
| |
| class StringWrapper extends $fidl.Struct { |
| const StringWrapper({ |
| @required this.str, |
| }); |
| StringWrapper.clone( |
| StringWrapper $orig, { |
| String str, |
| }) : this( |
| str: str ?? $orig.str, |
| ); |
| |
| StringWrapper._(List<Object> argv) : str = argv[0]; |
| final String str; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| str, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StringWrapper' r'(str: ' + str.toString() + r')'; |
| } |
| |
| static StringWrapper _ctor(List<Object> argv) => StringWrapper._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StringWrapper> kStringWrapper_Type = |
| $fidl.StructType<StringWrapper>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: StringWrapper._ctor, |
| ); |
| |
| class StructOfSimpleTable extends $fidl.Struct { |
| const StructOfSimpleTable({ |
| @required this.table, |
| }); |
| StructOfSimpleTable.clone( |
| StructOfSimpleTable $orig, { |
| SimpleTable table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| StructOfSimpleTable._(List<Object> argv) : table = argv[0]; |
| final SimpleTable table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructOfSimpleTable' r'(table: ' + table.toString() + r')'; |
| } |
| |
| static StructOfSimpleTable _ctor(List<Object> argv) => |
| StructOfSimpleTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructOfSimpleTable> kStructOfSimpleTable_Type = |
| $fidl.StructType<StructOfSimpleTable>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<SimpleTable>( |
| type: kSimpleTable_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StructOfSimpleTable._ctor, |
| ); |
| |
| class SimpleTableThenUint64 extends $fidl.Struct { |
| const SimpleTableThenUint64({ |
| @required this.table, |
| @required this.number, |
| }); |
| SimpleTableThenUint64.clone( |
| SimpleTableThenUint64 $orig, { |
| SimpleTable table, |
| int number, |
| }) : this( |
| table: table ?? $orig.table, |
| number: number ?? $orig.number, |
| ); |
| |
| SimpleTableThenUint64._(List<Object> argv) |
| : table = argv[0], |
| number = argv[1]; |
| final SimpleTable table; |
| final int number; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| number, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'SimpleTableThenUint64' r'(table: ' + |
| table.toString() + |
| r', number: ' + |
| number.toString() + |
| r')'; |
| } |
| |
| static SimpleTableThenUint64 _ctor(List<Object> argv) => |
| SimpleTableThenUint64._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<SimpleTableThenUint64> kSimpleTableThenUint64_Type = |
| $fidl.StructType<SimpleTableThenUint64>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<SimpleTable>( |
| type: kSimpleTable_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: SimpleTableThenUint64._ctor, |
| ); |
| |
| class StructOfTableWithStringAndVector extends $fidl.Struct { |
| const StructOfTableWithStringAndVector({ |
| @required this.table, |
| }); |
| StructOfTableWithStringAndVector.clone( |
| StructOfTableWithStringAndVector $orig, { |
| TableWithStringAndVector table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| StructOfTableWithStringAndVector._(List<Object> argv) : table = argv[0]; |
| final TableWithStringAndVector table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructOfTableWithStringAndVector' r'(table: ' + |
| table.toString() + |
| r')'; |
| } |
| |
| static StructOfTableWithStringAndVector _ctor(List<Object> argv) => |
| StructOfTableWithStringAndVector._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructOfTableWithStringAndVector> |
| kStructOfTableWithStringAndVector_Type = |
| $fidl.StructType<StructOfTableWithStringAndVector>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableWithStringAndVector>( |
| type: kTableWithStringAndVector_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StructOfTableWithStringAndVector._ctor, |
| ); |
| |
| class StructOfReverseOrdinalTable extends $fidl.Struct { |
| const StructOfReverseOrdinalTable({ |
| @required this.table, |
| }); |
| StructOfReverseOrdinalTable.clone( |
| StructOfReverseOrdinalTable $orig, { |
| ReverseOrdinalTable table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| StructOfReverseOrdinalTable._(List<Object> argv) : table = argv[0]; |
| final ReverseOrdinalTable table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructOfReverseOrdinalTable' r'(table: ' + table.toString() + r')'; |
| } |
| |
| static StructOfReverseOrdinalTable _ctor(List<Object> argv) => |
| StructOfReverseOrdinalTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructOfReverseOrdinalTable> |
| kStructOfReverseOrdinalTable_Type = |
| $fidl.StructType<StructOfReverseOrdinalTable>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<ReverseOrdinalTable>( |
| type: kReverseOrdinalTable_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StructOfReverseOrdinalTable._ctor, |
| ); |
| |
| class ThreeByte extends $fidl.Struct { |
| const ThreeByte({ |
| @required this.elem1, |
| @required this.elem2, |
| @required this.elem3, |
| }); |
| ThreeByte.clone( |
| ThreeByte $orig, { |
| int elem1, |
| int elem2, |
| int elem3, |
| }) : this( |
| elem1: elem1 ?? $orig.elem1, |
| elem2: elem2 ?? $orig.elem2, |
| elem3: elem3 ?? $orig.elem3, |
| ); |
| |
| ThreeByte._(List<Object> argv) |
| : elem1 = argv[0], |
| elem2 = argv[1], |
| elem3 = argv[2]; |
| final int elem1; |
| final int elem2; |
| final int elem3; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elem1, |
| elem2, |
| elem3, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'ThreeByte' r'(elem1: ' + |
| elem1.toString() + |
| r', elem2: ' + |
| elem2.toString() + |
| r', elem3: ' + |
| elem3.toString() + |
| r')'; |
| } |
| |
| static ThreeByte _ctor(List<Object> argv) => ThreeByte._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<ThreeByte> kThreeByte_Type = $fidl.StructType<ThreeByte>( |
| inlineSizeOld: 3, |
| inlineSizeV1: 3, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 1, offsetV1: 1), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 2, offsetV1: 2), |
| ], |
| ctor: ThreeByte._ctor, |
| ); |
| |
| class FiveByte extends $fidl.Struct { |
| const FiveByte({ |
| @required this.elem1, |
| @required this.elem2, |
| }); |
| FiveByte.clone( |
| FiveByte $orig, { |
| int elem1, |
| int elem2, |
| }) : this( |
| elem1: elem1 ?? $orig.elem1, |
| elem2: elem2 ?? $orig.elem2, |
| ); |
| |
| FiveByte._(List<Object> argv) |
| : elem1 = argv[0], |
| elem2 = argv[1]; |
| final int elem1; |
| final int elem2; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elem1, |
| elem2, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'FiveByte' r'(elem1: ' + |
| elem1.toString() + |
| r', elem2: ' + |
| elem2.toString() + |
| r')'; |
| } |
| |
| static FiveByte _ctor(List<Object> argv) => FiveByte._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<FiveByte> kFiveByte_Type = $fidl.StructType<FiveByte>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 4, offsetV1: 4), |
| ], |
| ctor: FiveByte._ctor, |
| ); |
| |
| class ThreeByteInStruct extends $fidl.Struct { |
| const ThreeByteInStruct({ |
| @required this.elem1, |
| @required this.elem2, |
| @required this.elem3, |
| }); |
| ThreeByteInStruct.clone( |
| ThreeByteInStruct $orig, { |
| ThreeByte elem1, |
| ThreeByte elem2, |
| ThreeByte elem3, |
| }) : this( |
| elem1: elem1 ?? $orig.elem1, |
| elem2: elem2 ?? $orig.elem2, |
| elem3: elem3 ?? $orig.elem3, |
| ); |
| |
| ThreeByteInStruct._(List<Object> argv) |
| : elem1 = argv[0], |
| elem2 = argv[1], |
| elem3 = argv[2]; |
| final ThreeByte elem1; |
| final ThreeByte elem2; |
| final ThreeByte elem3; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elem1, |
| elem2, |
| elem3, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'ThreeByteInStruct' r'(elem1: ' + |
| elem1.toString() + |
| r', elem2: ' + |
| elem2.toString() + |
| r', elem3: ' + |
| elem3.toString() + |
| r')'; |
| } |
| |
| static ThreeByteInStruct _ctor(List<Object> argv) => |
| ThreeByteInStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<ThreeByteInStruct> kThreeByteInStruct_Type = |
| $fidl.StructType<ThreeByteInStruct>( |
| inlineSizeOld: 9, |
| inlineSizeV1: 9, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<ThreeByte>( |
| type: kThreeByte_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<ThreeByte>( |
| type: kThreeByte_Type, offsetOld: 3, offsetV1: 3), |
| $fidl.MemberType<ThreeByte>( |
| type: kThreeByte_Type, offsetOld: 6, offsetV1: 6), |
| ], |
| ctor: ThreeByteInStruct._ctor, |
| ); |
| |
| class FiveByteInStruct extends $fidl.Struct { |
| const FiveByteInStruct({ |
| @required this.elem1, |
| @required this.elem2, |
| @required this.elem3, |
| }); |
| FiveByteInStruct.clone( |
| FiveByteInStruct $orig, { |
| FiveByte elem1, |
| FiveByte elem2, |
| FiveByte elem3, |
| }) : this( |
| elem1: elem1 ?? $orig.elem1, |
| elem2: elem2 ?? $orig.elem2, |
| elem3: elem3 ?? $orig.elem3, |
| ); |
| |
| FiveByteInStruct._(List<Object> argv) |
| : elem1 = argv[0], |
| elem2 = argv[1], |
| elem3 = argv[2]; |
| final FiveByte elem1; |
| final FiveByte elem2; |
| final FiveByte elem3; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elem1, |
| elem2, |
| elem3, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'FiveByteInStruct' r'(elem1: ' + |
| elem1.toString() + |
| r', elem2: ' + |
| elem2.toString() + |
| r', elem3: ' + |
| elem3.toString() + |
| r')'; |
| } |
| |
| static FiveByteInStruct _ctor(List<Object> argv) => FiveByteInStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<FiveByteInStruct> kFiveByteInStruct_Type = |
| $fidl.StructType<FiveByteInStruct>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<FiveByte>(type: kFiveByte_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<FiveByte>(type: kFiveByte_Type, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<FiveByte>( |
| type: kFiveByte_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: FiveByteInStruct._ctor, |
| ); |
| |
| class ThreeByteInVector extends $fidl.Struct { |
| const ThreeByteInVector({ |
| @required this.elems, |
| }); |
| ThreeByteInVector.clone( |
| ThreeByteInVector $orig, { |
| List<ThreeByte> elems, |
| }) : this( |
| elems: elems ?? $orig.elems, |
| ); |
| |
| ThreeByteInVector._(List<Object> argv) : elems = argv[0]; |
| final List<ThreeByte> elems; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elems, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'ThreeByteInVector' r'(elems: ' + elems.toString() + r')'; |
| } |
| |
| static ThreeByteInVector _ctor(List<Object> argv) => |
| ThreeByteInVector._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<ThreeByteInVector> kThreeByteInVector_Type = |
| $fidl.StructType<ThreeByteInVector>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<ThreeByte>>( |
| type: $fidl.VectorType<List<ThreeByte>>( |
| element: kThreeByte_Type, maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: ThreeByteInVector._ctor, |
| ); |
| |
| class FiveByteInVector extends $fidl.Struct { |
| const FiveByteInVector({ |
| @required this.elems, |
| }); |
| FiveByteInVector.clone( |
| FiveByteInVector $orig, { |
| List<FiveByte> elems, |
| }) : this( |
| elems: elems ?? $orig.elems, |
| ); |
| |
| FiveByteInVector._(List<Object> argv) : elems = argv[0]; |
| final List<FiveByte> elems; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elems, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'FiveByteInVector' r'(elems: ' + elems.toString() + r')'; |
| } |
| |
| static FiveByteInVector _ctor(List<Object> argv) => FiveByteInVector._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<FiveByteInVector> kFiveByteInVector_Type = |
| $fidl.StructType<FiveByteInVector>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<FiveByte>>( |
| type: $fidl.VectorType<List<FiveByte>>( |
| element: kFiveByte_Type, maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: FiveByteInVector._ctor, |
| ); |
| |
| class ThreeByteInArray extends $fidl.Struct { |
| const ThreeByteInArray({ |
| @required this.elems, |
| }); |
| ThreeByteInArray.clone( |
| ThreeByteInArray $orig, { |
| List<ThreeByte> elems, |
| }) : this( |
| elems: elems ?? $orig.elems, |
| ); |
| |
| ThreeByteInArray._(List<Object> argv) : elems = argv[0]; |
| final List<ThreeByte> elems; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elems, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'ThreeByteInArray' r'(elems: ' + elems.toString() + r')'; |
| } |
| |
| static ThreeByteInArray _ctor(List<Object> argv) => ThreeByteInArray._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<ThreeByteInArray> kThreeByteInArray_Type = |
| $fidl.StructType<ThreeByteInArray>( |
| inlineSizeOld: 9, |
| inlineSizeV1: 9, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<ThreeByte>>( |
| type: $fidl.ArrayType<List<ThreeByte>>( |
| element: kThreeByte_Type, elementCount: 3), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: ThreeByteInArray._ctor, |
| ); |
| |
| class FiveByteInArray extends $fidl.Struct { |
| const FiveByteInArray({ |
| @required this.elems, |
| }); |
| FiveByteInArray.clone( |
| FiveByteInArray $orig, { |
| List<FiveByte> elems, |
| }) : this( |
| elems: elems ?? $orig.elems, |
| ); |
| |
| FiveByteInArray._(List<Object> argv) : elems = argv[0]; |
| final List<FiveByte> elems; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| elems, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'FiveByteInArray' r'(elems: ' + elems.toString() + r')'; |
| } |
| |
| static FiveByteInArray _ctor(List<Object> argv) => FiveByteInArray._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<FiveByteInArray> kFiveByteInArray_Type = |
| $fidl.StructType<FiveByteInArray>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<FiveByte>>( |
| type: $fidl.ArrayType<List<FiveByte>>( |
| element: kFiveByte_Type, elementCount: 3), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: FiveByteInArray._ctor, |
| ); |
| |
| class MyBool extends $fidl.Struct { |
| const MyBool({ |
| @required this.value, |
| }); |
| MyBool.clone( |
| MyBool $orig, { |
| bool value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyBool._(List<Object> argv) : value = argv[0]; |
| final bool value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyBool' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyBool _ctor(List<Object> argv) => MyBool._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyBool> kMyBool_Type = $fidl.StructType<MyBool>( |
| inlineSizeOld: 1, |
| inlineSizeV1: 1, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<bool>(type: $fidl.BoolType(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyBool._ctor, |
| ); |
| |
| class MyByte extends $fidl.Struct { |
| const MyByte({ |
| @required this.value, |
| }); |
| MyByte.clone( |
| MyByte $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyByte._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyByte' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyByte _ctor(List<Object> argv) => MyByte._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyByte> kMyByte_Type = $fidl.StructType<MyByte>( |
| inlineSizeOld: 1, |
| inlineSizeV1: 1, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyByte._ctor, |
| ); |
| |
| class MyInt8 extends $fidl.Struct { |
| const MyInt8({ |
| @required this.value, |
| }); |
| MyInt8.clone( |
| MyInt8 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyInt8._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyInt8' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyInt8 _ctor(List<Object> argv) => MyInt8._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyInt8> kMyInt8_Type = $fidl.StructType<MyInt8>( |
| inlineSizeOld: 1, |
| inlineSizeV1: 1, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Int8Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyInt8._ctor, |
| ); |
| |
| class MyInt16 extends $fidl.Struct { |
| const MyInt16({ |
| @required this.value, |
| }); |
| MyInt16.clone( |
| MyInt16 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyInt16._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyInt16' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyInt16 _ctor(List<Object> argv) => MyInt16._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyInt16> kMyInt16_Type = $fidl.StructType<MyInt16>( |
| inlineSizeOld: 2, |
| inlineSizeV1: 2, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Int16Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyInt16._ctor, |
| ); |
| |
| class MyInt32 extends $fidl.Struct { |
| const MyInt32({ |
| @required this.value, |
| }); |
| MyInt32.clone( |
| MyInt32 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyInt32._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyInt32' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyInt32 _ctor(List<Object> argv) => MyInt32._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyInt32> kMyInt32_Type = $fidl.StructType<MyInt32>( |
| inlineSizeOld: 4, |
| inlineSizeV1: 4, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Int32Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyInt32._ctor, |
| ); |
| |
| class MyInt64 extends $fidl.Struct { |
| const MyInt64({ |
| @required this.value, |
| }); |
| MyInt64.clone( |
| MyInt64 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyInt64._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyInt64' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyInt64 _ctor(List<Object> argv) => MyInt64._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyInt64> kMyInt64_Type = $fidl.StructType<MyInt64>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Int64Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyInt64._ctor, |
| ); |
| |
| class MyUint8 extends $fidl.Struct { |
| const MyUint8({ |
| @required this.value, |
| }); |
| MyUint8.clone( |
| MyUint8 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyUint8._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyUint8' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyUint8 _ctor(List<Object> argv) => MyUint8._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyUint8> kMyUint8_Type = $fidl.StructType<MyUint8>( |
| inlineSizeOld: 1, |
| inlineSizeV1: 1, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyUint8._ctor, |
| ); |
| |
| class MyUint16 extends $fidl.Struct { |
| const MyUint16({ |
| @required this.value, |
| }); |
| MyUint16.clone( |
| MyUint16 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyUint16._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyUint16' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyUint16 _ctor(List<Object> argv) => MyUint16._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyUint16> kMyUint16_Type = $fidl.StructType<MyUint16>( |
| inlineSizeOld: 2, |
| inlineSizeV1: 2, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint16Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyUint16._ctor, |
| ); |
| |
| class MyUint32 extends $fidl.Struct { |
| const MyUint32({ |
| @required this.value, |
| }); |
| MyUint32.clone( |
| MyUint32 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyUint32._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyUint32' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyUint32 _ctor(List<Object> argv) => MyUint32._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyUint32> kMyUint32_Type = $fidl.StructType<MyUint32>( |
| inlineSizeOld: 4, |
| inlineSizeV1: 4, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyUint32._ctor, |
| ); |
| |
| class MyUint64 extends $fidl.Struct { |
| const MyUint64({ |
| @required this.value, |
| }); |
| MyUint64.clone( |
| MyUint64 $orig, { |
| int value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyUint64._(List<Object> argv) : value = argv[0]; |
| final int value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyUint64' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyUint64 _ctor(List<Object> argv) => MyUint64._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyUint64> kMyUint64_Type = $fidl.StructType<MyUint64>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyUint64._ctor, |
| ); |
| |
| class MyFloat32 extends $fidl.Struct { |
| const MyFloat32({ |
| @required this.value, |
| }); |
| MyFloat32.clone( |
| MyFloat32 $orig, { |
| double value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyFloat32._(List<Object> argv) : value = argv[0]; |
| final double value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyFloat32' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyFloat32 _ctor(List<Object> argv) => MyFloat32._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyFloat32> kMyFloat32_Type = $fidl.StructType<MyFloat32>( |
| inlineSizeOld: 4, |
| inlineSizeV1: 4, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<double>( |
| type: $fidl.Float32Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyFloat32._ctor, |
| ); |
| |
| class MyFloat64 extends $fidl.Struct { |
| const MyFloat64({ |
| @required this.value, |
| }); |
| MyFloat64.clone( |
| MyFloat64 $orig, { |
| double value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| MyFloat64._(List<Object> argv) : value = argv[0]; |
| final double value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MyFloat64' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static MyFloat64 _ctor(List<Object> argv) => MyFloat64._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MyFloat64> kMyFloat64_Type = $fidl.StructType<MyFloat64>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<double>( |
| type: $fidl.Float64Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: MyFloat64._ctor, |
| ); |
| |
| class StructWithOptionals extends $fidl.Struct { |
| const StructWithOptionals({ |
| @required this.s, |
| this.s2, |
| @required this.t, |
| @required this.xu, |
| this.xu2, |
| @required this.u, |
| this.u2, |
| }); |
| StructWithOptionals.clone( |
| StructWithOptionals $orig, { |
| EmptyStruct s, |
| EmptyStruct s2, |
| TableWithEmptyStruct t, |
| XUnionWithEmptyStruct xu, |
| XUnionWithEmptyStruct xu2, |
| UnionWithEmptyStruct u, |
| UnionWithEmptyStruct u2, |
| }) : this( |
| s: s ?? $orig.s, |
| s2: s2 ?? $orig.s2, |
| t: t ?? $orig.t, |
| xu: xu ?? $orig.xu, |
| xu2: xu2 ?? $orig.xu2, |
| u: u ?? $orig.u, |
| u2: u2 ?? $orig.u2, |
| ); |
| |
| StructWithOptionals.cloneWithout( |
| StructWithOptionals $orig, { |
| bool s2, |
| bool xu2, |
| bool u2, |
| }) : this( |
| s: $orig.s, |
| s2: s2 ? null : $orig.s2, |
| t: $orig.t, |
| xu: $orig.xu, |
| xu2: xu2 ? null : $orig.xu2, |
| u: $orig.u, |
| u2: u2 ? null : $orig.u2, |
| ); |
| |
| StructWithOptionals._(List<Object> argv) |
| : s = argv[0], |
| s2 = argv[1], |
| t = argv[2], |
| xu = argv[3], |
| xu2 = argv[4], |
| u = argv[5], |
| u2 = argv[6]; |
| final EmptyStruct s; |
| final EmptyStruct s2; |
| final TableWithEmptyStruct t; |
| final XUnionWithEmptyStruct xu; |
| final XUnionWithEmptyStruct xu2; |
| final UnionWithEmptyStruct u; |
| final UnionWithEmptyStruct u2; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| s, |
| s2, |
| t, |
| xu, |
| xu2, |
| u, |
| u2, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructWithOptionals' r'(s: ' + |
| s.toString() + |
| r', s2: ' + |
| s2.toString() + |
| r', t: ' + |
| t.toString() + |
| r', xu: ' + |
| xu.toString() + |
| r', xu2: ' + |
| xu2.toString() + |
| r', u: ' + |
| u.toString() + |
| r', u2: ' + |
| u2.toString() + |
| r')'; |
| } |
| |
| static StructWithOptionals _ctor(List<Object> argv) => |
| StructWithOptionals._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructWithOptionals> kStructWithOptionals_Type = |
| $fidl.StructType<StructWithOptionals>( |
| inlineSizeOld: 104, |
| inlineSizeV1: 128, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<EmptyStruct>( |
| type: kEmptyStruct_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<EmptyStruct>( |
| type: $fidl.PointerType<EmptyStruct>(element: kEmptyStruct_Type), |
| offsetOld: 8, |
| offsetV1: 8), |
| $fidl.MemberType<TableWithEmptyStruct>( |
| type: kTableWithEmptyStruct_Type, offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<XUnionWithEmptyStruct>( |
| type: kXUnionWithEmptyStruct_Type, offsetOld: 32, offsetV1: 32), |
| $fidl.MemberType<XUnionWithEmptyStruct>( |
| type: kXUnionWithEmptyStruct_OptType, offsetOld: 56, offsetV1: 56), |
| $fidl.MemberType<UnionWithEmptyStruct>( |
| type: kUnionWithEmptyStruct_Type, offsetOld: 80, offsetV1: 80), |
| $fidl.MemberType<UnionWithEmptyStruct>( |
| type: kUnionWithEmptyStruct_OptType, offsetOld: 96, offsetV1: 104), |
| ], |
| ctor: StructWithOptionals._ctor, |
| ); |
| |
| class TransactionHeader extends $fidl.Struct { |
| const TransactionHeader({ |
| @required this.txId, |
| @required this.flags, |
| @required this.magicNumber, |
| @required this.ordinal, |
| }); |
| TransactionHeader.clone( |
| TransactionHeader $orig, { |
| int txId, |
| Uint8List flags, |
| int magicNumber, |
| int ordinal, |
| }) : this( |
| txId: txId ?? $orig.txId, |
| flags: flags ?? $orig.flags, |
| magicNumber: magicNumber ?? $orig.magicNumber, |
| ordinal: ordinal ?? $orig.ordinal, |
| ); |
| |
| TransactionHeader._(List<Object> argv) |
| : txId = argv[0], |
| flags = argv[1], |
| magicNumber = argv[2], |
| ordinal = argv[3]; |
| final int txId; |
| final Uint8List flags; |
| final int magicNumber; |
| final int ordinal; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| txId, |
| flags, |
| magicNumber, |
| ordinal, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TransactionHeader' r'(txId: ' + |
| txId.toString() + |
| r', flags: ' + |
| flags.toString() + |
| r', magicNumber: ' + |
| magicNumber.toString() + |
| r', ordinal: ' + |
| ordinal.toString() + |
| r')'; |
| } |
| |
| static TransactionHeader _ctor(List<Object> argv) => |
| TransactionHeader._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TransactionHeader> kTransactionHeader_Type = |
| $fidl.StructType<TransactionHeader>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Uint8List>( |
| type: $fidl.ArrayType<Uint8List>( |
| element: $fidl.Uint8Type(), elementCount: 3), |
| offsetOld: 4, |
| offsetV1: 4), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 7, offsetV1: 7), |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 8, offsetV1: 8), |
| ], |
| ctor: TransactionHeader._ctor, |
| ); |
| |
| class StructSize16Align8 extends $fidl.Struct { |
| const StructSize16Align8({ |
| @required this.f1, |
| @required this.f2, |
| }); |
| StructSize16Align8.clone( |
| StructSize16Align8 $orig, { |
| int f1, |
| int f2, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| ); |
| |
| StructSize16Align8._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1]; |
| final int f1; |
| final int f2; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructSize16Align8' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r')'; |
| } |
| |
| static StructSize16Align8 _ctor(List<Object> argv) => |
| StructSize16Align8._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructSize16Align8> kStructSize16Align8_Type = |
| $fidl.StructType<StructSize16Align8>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 8, offsetV1: 8), |
| ], |
| ctor: StructSize16Align8._ctor, |
| ); |
| |
| class Sandwich1 extends $fidl.Struct { |
| const Sandwich1({ |
| @required this.before, |
| @required this.theUnion, |
| @required this.after, |
| }); |
| Sandwich1.clone( |
| Sandwich1 $orig, { |
| int before, |
| UnionSize8Align4 theUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| theUnion: theUnion ?? $orig.theUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich1._(List<Object> argv) |
| : before = argv[0], |
| theUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionSize8Align4 theUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| theUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich1' r'(before: ' + |
| before.toString() + |
| r', theUnion: ' + |
| theUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich1 _ctor(List<Object> argv) => Sandwich1._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich1> kSandwich1_Type = $fidl.StructType<Sandwich1>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionSize8Align4>( |
| type: kUnionSize8Align4_Type, offsetOld: 4, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 12, offsetV1: 32), |
| ], |
| ctor: Sandwich1._ctor, |
| ); |
| |
| class Sandwich1Message extends $fidl.Struct { |
| const Sandwich1Message({ |
| @required this.header, |
| @required this.body, |
| }); |
| Sandwich1Message.clone( |
| Sandwich1Message $orig, { |
| TransactionHeader header, |
| Sandwich1 body, |
| }) : this( |
| header: header ?? $orig.header, |
| body: body ?? $orig.body, |
| ); |
| |
| Sandwich1Message._(List<Object> argv) |
| : header = argv[0], |
| body = argv[1]; |
| final TransactionHeader header; |
| final Sandwich1 body; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| header, |
| body, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich1Message' r'(header: ' + |
| header.toString() + |
| r', body: ' + |
| body.toString() + |
| r')'; |
| } |
| |
| static Sandwich1Message _ctor(List<Object> argv) => Sandwich1Message._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich1Message> kSandwich1Message_Type = |
| $fidl.StructType<Sandwich1Message>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 56, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TransactionHeader>( |
| type: kTransactionHeader_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Sandwich1>( |
| type: kSandwich1_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: Sandwich1Message._ctor, |
| ); |
| |
| class Sandwich1WithOptUnion extends $fidl.Struct { |
| const Sandwich1WithOptUnion({ |
| @required this.before, |
| this.optUnion, |
| @required this.after, |
| }); |
| Sandwich1WithOptUnion.clone( |
| Sandwich1WithOptUnion $orig, { |
| int before, |
| UnionSize8Align4 optUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| optUnion: optUnion ?? $orig.optUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich1WithOptUnion.cloneWithout( |
| Sandwich1WithOptUnion $orig, { |
| bool optUnion, |
| }) : this( |
| before: $orig.before, |
| optUnion: optUnion ? null : $orig.optUnion, |
| after: $orig.after, |
| ); |
| |
| Sandwich1WithOptUnion._(List<Object> argv) |
| : before = argv[0], |
| optUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionSize8Align4 optUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| optUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich1WithOptUnion' r'(before: ' + |
| before.toString() + |
| r', optUnion: ' + |
| optUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich1WithOptUnion _ctor(List<Object> argv) => |
| Sandwich1WithOptUnion._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich1WithOptUnion> kSandwich1WithOptUnion_Type = |
| $fidl.StructType<Sandwich1WithOptUnion>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionSize8Align4>( |
| type: kUnionSize8Align4_OptType, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 16, offsetV1: 32), |
| ], |
| ctor: Sandwich1WithOptUnion._ctor, |
| ); |
| |
| class Sandwich2 extends $fidl.Struct { |
| const Sandwich2({ |
| @required this.before, |
| @required this.theUnion, |
| @required this.after, |
| }); |
| Sandwich2.clone( |
| Sandwich2 $orig, { |
| int before, |
| UnionSize12Align4 theUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| theUnion: theUnion ?? $orig.theUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich2._(List<Object> argv) |
| : before = argv[0], |
| theUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionSize12Align4 theUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| theUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich2' r'(before: ' + |
| before.toString() + |
| r', theUnion: ' + |
| theUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich2 _ctor(List<Object> argv) => Sandwich2._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich2> kSandwich2_Type = $fidl.StructType<Sandwich2>( |
| inlineSizeOld: 20, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionSize12Align4>( |
| type: kUnionSize12Align4_Type, offsetOld: 4, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 16, offsetV1: 32), |
| ], |
| ctor: Sandwich2._ctor, |
| ); |
| |
| class Sandwich3 extends $fidl.Struct { |
| const Sandwich3({ |
| @required this.before, |
| @required this.theUnion, |
| @required this.after, |
| }); |
| Sandwich3.clone( |
| Sandwich3 $orig, { |
| int before, |
| UnionSize24Align8 theUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| theUnion: theUnion ?? $orig.theUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich3._(List<Object> argv) |
| : before = argv[0], |
| theUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionSize24Align8 theUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| theUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich3' r'(before: ' + |
| before.toString() + |
| r', theUnion: ' + |
| theUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich3 _ctor(List<Object> argv) => Sandwich3._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich3> kSandwich3_Type = $fidl.StructType<Sandwich3>( |
| inlineSizeOld: 40, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionSize24Align8>( |
| type: kUnionSize24Align8_Type, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 32, offsetV1: 32), |
| ], |
| ctor: Sandwich3._ctor, |
| ); |
| |
| class Sandwich4 extends $fidl.Struct { |
| const Sandwich4({ |
| @required this.before, |
| @required this.theUnion, |
| @required this.after, |
| }); |
| Sandwich4.clone( |
| Sandwich4 $orig, { |
| int before, |
| UnionSize36Align4 theUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| theUnion: theUnion ?? $orig.theUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich4._(List<Object> argv) |
| : before = argv[0], |
| theUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionSize36Align4 theUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| theUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich4' r'(before: ' + |
| before.toString() + |
| r', theUnion: ' + |
| theUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich4 _ctor(List<Object> argv) => Sandwich4._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich4> kSandwich4_Type = $fidl.StructType<Sandwich4>( |
| inlineSizeOld: 44, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionSize36Align4>( |
| type: kUnionSize36Align4_Type, offsetOld: 4, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 40, offsetV1: 32), |
| ], |
| ctor: Sandwich4._ctor, |
| ); |
| |
| class Sandwich4Message extends $fidl.Struct { |
| const Sandwich4Message({ |
| @required this.header, |
| @required this.body, |
| }); |
| Sandwich4Message.clone( |
| Sandwich4Message $orig, { |
| TransactionHeader header, |
| Sandwich4 body, |
| }) : this( |
| header: header ?? $orig.header, |
| body: body ?? $orig.body, |
| ); |
| |
| Sandwich4Message._(List<Object> argv) |
| : header = argv[0], |
| body = argv[1]; |
| final TransactionHeader header; |
| final Sandwich4 body; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| header, |
| body, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich4Message' r'(header: ' + |
| header.toString() + |
| r', body: ' + |
| body.toString() + |
| r')'; |
| } |
| |
| static Sandwich4Message _ctor(List<Object> argv) => Sandwich4Message._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich4Message> kSandwich4Message_Type = |
| $fidl.StructType<Sandwich4Message>( |
| inlineSizeOld: 64, |
| inlineSizeV1: 56, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TransactionHeader>( |
| type: kTransactionHeader_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Sandwich4>( |
| type: kSandwich4_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: Sandwich4Message._ctor, |
| ); |
| |
| class Sandwich5 extends $fidl.Struct { |
| const Sandwich5({ |
| @required this.before, |
| @required this.unionOfUnion, |
| @required this.after, |
| }); |
| Sandwich5.clone( |
| Sandwich5 $orig, { |
| int before, |
| UnionOfUnion unionOfUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| unionOfUnion: unionOfUnion ?? $orig.unionOfUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich5._(List<Object> argv) |
| : before = argv[0], |
| unionOfUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionOfUnion unionOfUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| unionOfUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich5' r'(before: ' + |
| before.toString() + |
| r', unionOfUnion: ' + |
| unionOfUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich5 _ctor(List<Object> argv) => Sandwich5._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich5> kSandwich5_Type = $fidl.StructType<Sandwich5>( |
| inlineSizeOld: 48, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionOfUnion>( |
| type: kUnionOfUnion_Type, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 40, offsetV1: 32), |
| ], |
| ctor: Sandwich5._ctor, |
| ); |
| |
| class Sandwich5Message extends $fidl.Struct { |
| const Sandwich5Message({ |
| @required this.header, |
| @required this.body, |
| }); |
| Sandwich5Message.clone( |
| Sandwich5Message $orig, { |
| TransactionHeader header, |
| Sandwich5 body, |
| }) : this( |
| header: header ?? $orig.header, |
| body: body ?? $orig.body, |
| ); |
| |
| Sandwich5Message._(List<Object> argv) |
| : header = argv[0], |
| body = argv[1]; |
| final TransactionHeader header; |
| final Sandwich5 body; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| header, |
| body, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich5Message' r'(header: ' + |
| header.toString() + |
| r', body: ' + |
| body.toString() + |
| r')'; |
| } |
| |
| static Sandwich5Message _ctor(List<Object> argv) => Sandwich5Message._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich5Message> kSandwich5Message_Type = |
| $fidl.StructType<Sandwich5Message>( |
| inlineSizeOld: 64, |
| inlineSizeV1: 56, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TransactionHeader>( |
| type: kTransactionHeader_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Sandwich5>( |
| type: kSandwich5_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: Sandwich5Message._ctor, |
| ); |
| |
| class StructSize3Align1 extends $fidl.Struct { |
| const StructSize3Align1({ |
| @required this.threeBytes, |
| }); |
| StructSize3Align1.clone( |
| StructSize3Align1 $orig, { |
| Uint8List threeBytes, |
| }) : this( |
| threeBytes: threeBytes ?? $orig.threeBytes, |
| ); |
| |
| StructSize3Align1._(List<Object> argv) : threeBytes = argv[0]; |
| final Uint8List threeBytes; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| threeBytes, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructSize3Align1' r'(threeBytes: ' + threeBytes.toString() + r')'; |
| } |
| |
| static StructSize3Align1 _ctor(List<Object> argv) => |
| StructSize3Align1._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructSize3Align1> kStructSize3Align1_Type = |
| $fidl.StructType<StructSize3Align1>( |
| inlineSizeOld: 3, |
| inlineSizeV1: 3, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Uint8List>( |
| type: $fidl.ArrayType<Uint8List>( |
| element: $fidl.Uint8Type(), elementCount: 3), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: StructSize3Align1._ctor, |
| ); |
| |
| class StructSize3Align2 extends $fidl.Struct { |
| const StructSize3Align2({ |
| @required this.f1, |
| @required this.f2, |
| }); |
| StructSize3Align2.clone( |
| StructSize3Align2 $orig, { |
| int f1, |
| int f2, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| ); |
| |
| StructSize3Align2._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1]; |
| final int f1; |
| final int f2; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructSize3Align2' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r')'; |
| } |
| |
| static StructSize3Align2 _ctor(List<Object> argv) => |
| StructSize3Align2._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructSize3Align2> kStructSize3Align2_Type = |
| $fidl.StructType<StructSize3Align2>( |
| inlineSizeOld: 4, |
| inlineSizeV1: 4, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint16Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 2, offsetV1: 2), |
| ], |
| ctor: StructSize3Align2._ctor, |
| ); |
| |
| class Sandwich6 extends $fidl.Struct { |
| const Sandwich6({ |
| @required this.before, |
| @required this.theUnion, |
| @required this.after, |
| }); |
| Sandwich6.clone( |
| Sandwich6 $orig, { |
| int before, |
| UnionWithVector theUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| theUnion: theUnion ?? $orig.theUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich6._(List<Object> argv) |
| : before = argv[0], |
| theUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionWithVector theUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| theUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich6' r'(before: ' + |
| before.toString() + |
| r', theUnion: ' + |
| theUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich6 _ctor(List<Object> argv) => Sandwich6._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich6> kSandwich6_Type = $fidl.StructType<Sandwich6>( |
| inlineSizeOld: 40, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionWithVector>( |
| type: kUnionWithVector_Type, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 32, offsetV1: 32), |
| ], |
| ctor: Sandwich6._ctor, |
| ); |
| |
| class Sandwich7 extends $fidl.Struct { |
| const Sandwich7({ |
| @required this.before, |
| this.optSandwich1, |
| @required this.after, |
| }); |
| Sandwich7.clone( |
| Sandwich7 $orig, { |
| int before, |
| Sandwich1 optSandwich1, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| optSandwich1: optSandwich1 ?? $orig.optSandwich1, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich7.cloneWithout( |
| Sandwich7 $orig, { |
| bool optSandwich1, |
| }) : this( |
| before: $orig.before, |
| optSandwich1: optSandwich1 ? null : $orig.optSandwich1, |
| after: $orig.after, |
| ); |
| |
| Sandwich7._(List<Object> argv) |
| : before = argv[0], |
| optSandwich1 = argv[1], |
| after = argv[2]; |
| final int before; |
| final Sandwich1 optSandwich1; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| optSandwich1, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich7' r'(before: ' + |
| before.toString() + |
| r', optSandwich1: ' + |
| optSandwich1.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich7 _ctor(List<Object> argv) => Sandwich7._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich7> kSandwich7_Type = $fidl.StructType<Sandwich7>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Sandwich1>( |
| type: $fidl.PointerType<Sandwich1>(element: kSandwich1_Type), |
| offsetOld: 8, |
| offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: Sandwich7._ctor, |
| ); |
| |
| class Sandwich7Message extends $fidl.Struct { |
| const Sandwich7Message({ |
| @required this.header, |
| @required this.body, |
| }); |
| Sandwich7Message.clone( |
| Sandwich7Message $orig, { |
| TransactionHeader header, |
| Sandwich7 body, |
| }) : this( |
| header: header ?? $orig.header, |
| body: body ?? $orig.body, |
| ); |
| |
| Sandwich7Message._(List<Object> argv) |
| : header = argv[0], |
| body = argv[1]; |
| final TransactionHeader header; |
| final Sandwich7 body; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| header, |
| body, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich7Message' r'(header: ' + |
| header.toString() + |
| r', body: ' + |
| body.toString() + |
| r')'; |
| } |
| |
| static Sandwich7Message _ctor(List<Object> argv) => Sandwich7Message._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich7Message> kSandwich7Message_Type = |
| $fidl.StructType<Sandwich7Message>( |
| inlineSizeOld: 40, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TransactionHeader>( |
| type: kTransactionHeader_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Sandwich7>( |
| type: kSandwich7_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: Sandwich7Message._ctor, |
| ); |
| |
| class Sandwich8 extends $fidl.Struct { |
| const Sandwich8({ |
| @required this.before, |
| @required this.unionOfUnion, |
| @required this.after, |
| }); |
| Sandwich8.clone( |
| Sandwich8 $orig, { |
| int before, |
| UnionOfUnion unionOfUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| unionOfUnion: unionOfUnion ?? $orig.unionOfUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich8._(List<Object> argv) |
| : before = argv[0], |
| unionOfUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionOfUnion unionOfUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| unionOfUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich8' r'(before: ' + |
| before.toString() + |
| r', unionOfUnion: ' + |
| unionOfUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich8 _ctor(List<Object> argv) => Sandwich8._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich8> kSandwich8_Type = $fidl.StructType<Sandwich8>( |
| inlineSizeOld: 48, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionOfUnion>( |
| type: kUnionOfUnion_Type, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 40, offsetV1: 32), |
| ], |
| ctor: Sandwich8._ctor, |
| ); |
| |
| class Regression1 extends $fidl.Struct { |
| const Regression1({ |
| @required this.f1, |
| @required this.f2, |
| @required this.f3, |
| @required this.f4, |
| @required this.f5, |
| @required this.f6, |
| }); |
| Regression1.clone( |
| Regression1 $orig, { |
| int f1, |
| int f2, |
| int f3, |
| int f4, |
| int f5, |
| int f6, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| f3: f3 ?? $orig.f3, |
| f4: f4 ?? $orig.f4, |
| f5: f5 ?? $orig.f5, |
| f6: f6 ?? $orig.f6, |
| ); |
| |
| Regression1._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1], |
| f3 = argv[2], |
| f4 = argv[3], |
| f5 = argv[4], |
| f6 = argv[5]; |
| final int f1; |
| final int f2; |
| final int f3; |
| final int f4; |
| final int f5; |
| final int f6; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| f3, |
| f4, |
| f5, |
| f6, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression1' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r', f3: ' + |
| f3.toString() + |
| r', f4: ' + |
| f4.toString() + |
| r', f5: ' + |
| f5.toString() + |
| r', f6: ' + |
| f6.toString() + |
| r')'; |
| } |
| |
| static Regression1 _ctor(List<Object> argv) => Regression1._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression1> kRegression1_Type = |
| $fidl.StructType<Regression1>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 32, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 4, offsetV1: 4), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint16Type(), offsetOld: 10, offsetV1: 10), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 24, offsetV1: 24), |
| ], |
| ctor: Regression1._ctor, |
| ); |
| |
| class Regression2 extends $fidl.Struct { |
| const Regression2({ |
| @required this.head, |
| @required this.f7, |
| }); |
| Regression2.clone( |
| Regression2 $orig, { |
| Regression1 head, |
| int f7, |
| }) : this( |
| head: head ?? $orig.head, |
| f7: f7 ?? $orig.f7, |
| ); |
| |
| Regression2._(List<Object> argv) |
| : head = argv[0], |
| f7 = argv[1]; |
| final Regression1 head; |
| final int f7; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| head, |
| f7, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression2' r'(head: ' + |
| head.toString() + |
| r', f7: ' + |
| f7.toString() + |
| r')'; |
| } |
| |
| static Regression2 _ctor(List<Object> argv) => Regression2._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression2> kRegression2_Type = |
| $fidl.StructType<Regression2>( |
| inlineSizeOld: 40, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Regression1>( |
| type: kRegression1_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 32, offsetV1: 32), |
| ], |
| ctor: Regression2._ctor, |
| ); |
| |
| class Regression3 extends $fidl.Struct { |
| const Regression3({ |
| this.optValue, |
| }); |
| Regression3.clone( |
| Regression3 $orig, { |
| Regression2 optValue, |
| }) : this( |
| optValue: optValue ?? $orig.optValue, |
| ); |
| |
| Regression3.cloneWithout( |
| Regression3 $orig, { |
| bool optValue, |
| }) : this( |
| optValue: optValue ? null : $orig.optValue, |
| ); |
| |
| Regression3._(List<Object> argv) : optValue = argv[0]; |
| final Regression2 optValue; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| optValue, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression3' r'(optValue: ' + optValue.toString() + r')'; |
| } |
| |
| static Regression3 _ctor(List<Object> argv) => Regression3._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression3> kRegression3_Type = |
| $fidl.StructType<Regression3>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Regression2>( |
| type: $fidl.PointerType<Regression2>(element: kRegression2_Type), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Regression3._ctor, |
| ); |
| |
| class StructTableNoFields extends $fidl.Struct { |
| const StructTableNoFields({ |
| @required this.t, |
| }); |
| StructTableNoFields.clone( |
| StructTableNoFields $orig, { |
| TableNoFields t, |
| }) : this( |
| t: t ?? $orig.t, |
| ); |
| |
| StructTableNoFields._(List<Object> argv) : t = argv[0]; |
| final TableNoFields t; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| t, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructTableNoFields' r'(t: ' + t.toString() + r')'; |
| } |
| |
| static StructTableNoFields _ctor(List<Object> argv) => |
| StructTableNoFields._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructTableNoFields> kStruct_Table_NoFields_Type = |
| $fidl.StructType<StructTableNoFields>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableNoFields>( |
| type: kTable_NoFields_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StructTableNoFields._ctor, |
| ); |
| |
| class StructTableTwoReservedFields extends $fidl.Struct { |
| const StructTableTwoReservedFields({ |
| @required this.t, |
| }); |
| StructTableTwoReservedFields.clone( |
| StructTableTwoReservedFields $orig, { |
| TableTwoReservedFields t, |
| }) : this( |
| t: t ?? $orig.t, |
| ); |
| |
| StructTableTwoReservedFields._(List<Object> argv) : t = argv[0]; |
| final TableTwoReservedFields t; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| t, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructTableTwoReservedFields' r'(t: ' + t.toString() + r')'; |
| } |
| |
| static StructTableTwoReservedFields _ctor(List<Object> argv) => |
| StructTableTwoReservedFields._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructTableTwoReservedFields> |
| kStruct_Table_TwoReservedFields_Type = |
| $fidl.StructType<StructTableTwoReservedFields>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableTwoReservedFields>( |
| type: kTable_TwoReservedFields_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StructTableTwoReservedFields._ctor, |
| ); |
| |
| class TableStructWithReservedSandwichStruct extends $fidl.Struct { |
| const TableStructWithReservedSandwichStruct({ |
| @required this.table, |
| }); |
| TableStructWithReservedSandwichStruct.clone( |
| TableStructWithReservedSandwichStruct $orig, { |
| TableStructWithReservedSandwich table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| TableStructWithReservedSandwichStruct._(List<Object> argv) : table = argv[0]; |
| final TableStructWithReservedSandwich table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TableStructWithReservedSandwichStruct' r'(table: ' + |
| table.toString() + |
| r')'; |
| } |
| |
| static TableStructWithReservedSandwichStruct _ctor(List<Object> argv) => |
| TableStructWithReservedSandwichStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TableStructWithReservedSandwichStruct> |
| kTable_StructWithReservedSandwichStruct_Type = |
| $fidl.StructType<TableStructWithReservedSandwichStruct>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableStructWithReservedSandwich>( |
| type: kTable_StructWithReservedSandwich_Type, |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: TableStructWithReservedSandwichStruct._ctor, |
| ); |
| |
| class TableStructWithUint32SandwichStruct extends $fidl.Struct { |
| const TableStructWithUint32SandwichStruct({ |
| @required this.table, |
| }); |
| TableStructWithUint32SandwichStruct.clone( |
| TableStructWithUint32SandwichStruct $orig, { |
| TableStructWithUint32Sandwich table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| TableStructWithUint32SandwichStruct._(List<Object> argv) : table = argv[0]; |
| final TableStructWithUint32Sandwich table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TableStructWithUint32SandwichStruct' r'(table: ' + |
| table.toString() + |
| r')'; |
| } |
| |
| static TableStructWithUint32SandwichStruct _ctor(List<Object> argv) => |
| TableStructWithUint32SandwichStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TableStructWithUint32SandwichStruct> |
| kTable_StructWithUint32SandwichStruct_Type = |
| $fidl.StructType<TableStructWithUint32SandwichStruct>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableStructWithUint32Sandwich>( |
| type: kTable_StructWithUint32Sandwich_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: TableStructWithUint32SandwichStruct._ctor, |
| ); |
| |
| class TableUnionWithVectorReservedSandwichStruct extends $fidl.Struct { |
| const TableUnionWithVectorReservedSandwichStruct({ |
| @required this.table, |
| }); |
| TableUnionWithVectorReservedSandwichStruct.clone( |
| TableUnionWithVectorReservedSandwichStruct $orig, { |
| TableUnionWithVectorReservedSandwich table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| TableUnionWithVectorReservedSandwichStruct._(List<Object> argv) |
| : table = argv[0]; |
| final TableUnionWithVectorReservedSandwich table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TableUnionWithVectorReservedSandwichStruct' r'(table: ' + |
| table.toString() + |
| r')'; |
| } |
| |
| static TableUnionWithVectorReservedSandwichStruct _ctor(List<Object> argv) => |
| TableUnionWithVectorReservedSandwichStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TableUnionWithVectorReservedSandwichStruct> |
| kTable_UnionWithVector_ReservedSandwichStruct_Type = |
| $fidl.StructType<TableUnionWithVectorReservedSandwichStruct>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableUnionWithVectorReservedSandwich>( |
| type: kTable_UnionWithVector_ReservedSandwich_Type, |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: TableUnionWithVectorReservedSandwichStruct._ctor, |
| ); |
| |
| class TableUnionWithVectorStructSandwichStruct extends $fidl.Struct { |
| const TableUnionWithVectorStructSandwichStruct({ |
| @required this.table, |
| }); |
| TableUnionWithVectorStructSandwichStruct.clone( |
| TableUnionWithVectorStructSandwichStruct $orig, { |
| TableUnionWithVectorStructSandwich table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| TableUnionWithVectorStructSandwichStruct._(List<Object> argv) |
| : table = argv[0]; |
| final TableUnionWithVectorStructSandwich table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TableUnionWithVectorStructSandwichStruct' r'(table: ' + |
| table.toString() + |
| r')'; |
| } |
| |
| static TableUnionWithVectorStructSandwichStruct _ctor(List<Object> argv) => |
| TableUnionWithVectorStructSandwichStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TableUnionWithVectorStructSandwichStruct> |
| kTable_UnionWithVector_StructSandwichStruct_Type = |
| $fidl.StructType<TableUnionWithVectorStructSandwichStruct>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableUnionWithVectorStructSandwich>( |
| type: kTable_UnionWithVector_StructSandwich_Type, |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: TableUnionWithVectorStructSandwichStruct._ctor, |
| ); |
| |
| class XUnionWithStructStruct extends $fidl.Struct { |
| const XUnionWithStructStruct({ |
| @required this.xu, |
| }); |
| XUnionWithStructStruct.clone( |
| XUnionWithStructStruct $orig, { |
| XUnionWithStruct xu, |
| }) : this( |
| xu: xu ?? $orig.xu, |
| ); |
| |
| XUnionWithStructStruct._(List<Object> argv) : xu = argv[0]; |
| final XUnionWithStruct xu; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| xu, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'XUnionWithStructStruct' r'(xu: ' + xu.toString() + r')'; |
| } |
| |
| static XUnionWithStructStruct _ctor(List<Object> argv) => |
| XUnionWithStructStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<XUnionWithStructStruct> kXUnionWithStructStruct_Type = |
| $fidl.StructType<XUnionWithStructStruct>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<XUnionWithStruct>( |
| type: kXUnionWithStruct_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: XUnionWithStructStruct._ctor, |
| ); |
| |
| class XUnionWithXUnionStruct extends $fidl.Struct { |
| const XUnionWithXUnionStruct({ |
| @required this.xu, |
| }); |
| XUnionWithXUnionStruct.clone( |
| XUnionWithXUnionStruct $orig, { |
| XUnionWithXUnion xu, |
| }) : this( |
| xu: xu ?? $orig.xu, |
| ); |
| |
| XUnionWithXUnionStruct._(List<Object> argv) : xu = argv[0]; |
| final XUnionWithXUnion xu; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| xu, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'XUnionWithXUnionStruct' r'(xu: ' + xu.toString() + r')'; |
| } |
| |
| static XUnionWithXUnionStruct _ctor(List<Object> argv) => |
| XUnionWithXUnionStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<XUnionWithXUnionStruct> kXUnionWithXUnionStruct_Type = |
| $fidl.StructType<XUnionWithXUnionStruct>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<XUnionWithXUnion>( |
| type: kXUnionWithXUnion_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: XUnionWithXUnionStruct._ctor, |
| ); |
| |
| class Size5Alignment1 extends $fidl.Struct { |
| const Size5Alignment1({ |
| @required this.data, |
| }); |
| Size5Alignment1.clone( |
| Size5Alignment1 $orig, { |
| Uint8List data, |
| }) : this( |
| data: data ?? $orig.data, |
| ); |
| |
| Size5Alignment1._(List<Object> argv) : data = argv[0]; |
| final Uint8List data; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| data, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Size5Alignment1' r'(data: ' + data.toString() + r')'; |
| } |
| |
| static Size5Alignment1 _ctor(List<Object> argv) => Size5Alignment1._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Size5Alignment1> kSize5Alignment1_Type = |
| $fidl.StructType<Size5Alignment1>( |
| inlineSizeOld: 5, |
| inlineSizeV1: 5, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Uint8List>( |
| type: $fidl.ArrayType<Uint8List>( |
| element: $fidl.Uint8Type(), elementCount: 5), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Size5Alignment1._ctor, |
| ); |
| |
| class Size5Alignment4 extends $fidl.Struct { |
| const Size5Alignment4({ |
| @required this.four, |
| @required this.one, |
| }); |
| Size5Alignment4.clone( |
| Size5Alignment4 $orig, { |
| int four, |
| int one, |
| }) : this( |
| four: four ?? $orig.four, |
| one: one ?? $orig.one, |
| ); |
| |
| Size5Alignment4._(List<Object> argv) |
| : four = argv[0], |
| one = argv[1]; |
| final int four; |
| final int one; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| four, |
| one, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Size5Alignment4' r'(four: ' + |
| four.toString() + |
| r', one: ' + |
| one.toString() + |
| r')'; |
| } |
| |
| static Size5Alignment4 _ctor(List<Object> argv) => Size5Alignment4._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Size5Alignment4> kSize5Alignment4_Type = |
| $fidl.StructType<Size5Alignment4>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 4, offsetV1: 4), |
| ], |
| ctor: Size5Alignment4._ctor, |
| ); |
| |
| class Size5Alignment1Vector extends $fidl.Struct { |
| const Size5Alignment1Vector({ |
| @required this.v, |
| }); |
| Size5Alignment1Vector.clone( |
| Size5Alignment1Vector $orig, { |
| List<Size5Alignment1> v, |
| }) : this( |
| v: v ?? $orig.v, |
| ); |
| |
| Size5Alignment1Vector._(List<Object> argv) : v = argv[0]; |
| final List<Size5Alignment1> v; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| v, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Size5Alignment1Vector' r'(v: ' + v.toString() + r')'; |
| } |
| |
| static Size5Alignment1Vector _ctor(List<Object> argv) => |
| Size5Alignment1Vector._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Size5Alignment1Vector> kSize5Alignment1Vector_Type = |
| $fidl.StructType<Size5Alignment1Vector>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<Size5Alignment1>>( |
| type: $fidl.VectorType<List<Size5Alignment1>>( |
| element: kSize5Alignment1_Type, |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Size5Alignment1Vector._ctor, |
| ); |
| |
| class Size5Alignment4Vector extends $fidl.Struct { |
| const Size5Alignment4Vector({ |
| @required this.v, |
| }); |
| Size5Alignment4Vector.clone( |
| Size5Alignment4Vector $orig, { |
| List<Size5Alignment4> v, |
| }) : this( |
| v: v ?? $orig.v, |
| ); |
| |
| Size5Alignment4Vector._(List<Object> argv) : v = argv[0]; |
| final List<Size5Alignment4> v; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| v, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Size5Alignment4Vector' r'(v: ' + v.toString() + r')'; |
| } |
| |
| static Size5Alignment4Vector _ctor(List<Object> argv) => |
| Size5Alignment4Vector._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Size5Alignment4Vector> kSize5Alignment4Vector_Type = |
| $fidl.StructType<Size5Alignment4Vector>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<Size5Alignment4>>( |
| type: $fidl.VectorType<List<Size5Alignment4>>( |
| element: kSize5Alignment4_Type, |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Size5Alignment4Vector._ctor, |
| ); |
| |
| class Size5Alignment1Array extends $fidl.Struct { |
| const Size5Alignment1Array({ |
| @required this.a, |
| }); |
| Size5Alignment1Array.clone( |
| Size5Alignment1Array $orig, { |
| List<Size5Alignment1> a, |
| }) : this( |
| a: a ?? $orig.a, |
| ); |
| |
| Size5Alignment1Array._(List<Object> argv) : a = argv[0]; |
| final List<Size5Alignment1> a; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| a, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Size5Alignment1Array' r'(a: ' + a.toString() + r')'; |
| } |
| |
| static Size5Alignment1Array _ctor(List<Object> argv) => |
| Size5Alignment1Array._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Size5Alignment1Array> kSize5Alignment1Array_Type = |
| $fidl.StructType<Size5Alignment1Array>( |
| inlineSizeOld: 15, |
| inlineSizeV1: 15, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<Size5Alignment1>>( |
| type: $fidl.ArrayType<List<Size5Alignment1>>( |
| element: kSize5Alignment1_Type, elementCount: 3), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Size5Alignment1Array._ctor, |
| ); |
| |
| class Size5Alignment4Array extends $fidl.Struct { |
| const Size5Alignment4Array({ |
| @required this.a, |
| }); |
| Size5Alignment4Array.clone( |
| Size5Alignment4Array $orig, { |
| List<Size5Alignment4> a, |
| }) : this( |
| a: a ?? $orig.a, |
| ); |
| |
| Size5Alignment4Array._(List<Object> argv) : a = argv[0]; |
| final List<Size5Alignment4> a; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| a, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Size5Alignment4Array' r'(a: ' + a.toString() + r')'; |
| } |
| |
| static Size5Alignment4Array _ctor(List<Object> argv) => |
| Size5Alignment4Array._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Size5Alignment4Array> kSize5Alignment4Array_Type = |
| $fidl.StructType<Size5Alignment4Array>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<Size5Alignment4>>( |
| type: $fidl.ArrayType<List<Size5Alignment4>>( |
| element: kSize5Alignment4_Type, elementCount: 3), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Size5Alignment4Array._ctor, |
| ); |
| |
| class ArrayStruct extends $fidl.Struct { |
| const ArrayStruct({ |
| @required this.unions, |
| @required this.optionalUnions, |
| }); |
| ArrayStruct.clone( |
| ArrayStruct $orig, { |
| List<StringUnion> unions, |
| List<StringUnion> optionalUnions, |
| }) : this( |
| unions: unions ?? $orig.unions, |
| optionalUnions: optionalUnions ?? $orig.optionalUnions, |
| ); |
| |
| ArrayStruct._(List<Object> argv) |
| : unions = argv[0], |
| optionalUnions = argv[1]; |
| final List<StringUnion> unions; |
| final List<StringUnion> optionalUnions; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| unions, |
| optionalUnions, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'ArrayStruct' r'(unions: ' + |
| unions.toString() + |
| r', optionalUnions: ' + |
| optionalUnions.toString() + |
| r')'; |
| } |
| |
| static ArrayStruct _ctor(List<Object> argv) => ArrayStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<ArrayStruct> kArrayStruct_Type = |
| $fidl.StructType<ArrayStruct>( |
| inlineSizeOld: 96, |
| inlineSizeV1: 144, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<StringUnion>>( |
| type: $fidl.ArrayType<List<StringUnion>>( |
| element: kStringUnion_Type, elementCount: 3), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<List<StringUnion>>( |
| type: $fidl.ArrayType<List<StringUnion>>( |
| element: kStringUnion_OptType, elementCount: 3), |
| offsetOld: 72, |
| offsetV1: 72), |
| ], |
| ctor: ArrayStruct._ctor, |
| ); |
| |
| class TransformerEmptyStruct extends $fidl.Struct { |
| const TransformerEmptyStruct({ |
| this.reserved: 0x0, |
| }); |
| TransformerEmptyStruct.clone( |
| TransformerEmptyStruct $orig, { |
| int reserved, |
| }) : this( |
| reserved: reserved ?? $orig.reserved, |
| ); |
| |
| TransformerEmptyStruct._(List<Object> argv) : reserved = argv[0]; |
| final int reserved; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| reserved, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TransformerEmptyStruct' r'(reserved: ' + |
| reserved.toString() + |
| r')'; |
| } |
| |
| static TransformerEmptyStruct _ctor(List<Object> argv) => |
| TransformerEmptyStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TransformerEmptyStruct> kTransformerEmptyStruct_Type = |
| $fidl.StructType<TransformerEmptyStruct>( |
| inlineSizeOld: 1, |
| inlineSizeV1: 1, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: TransformerEmptyStruct._ctor, |
| ); |
| |
| class EmptyStructUnionStruct extends $fidl.Struct { |
| const EmptyStructUnionStruct({ |
| @required this.u, |
| }); |
| EmptyStructUnionStruct.clone( |
| EmptyStructUnionStruct $orig, { |
| EmptyStructUnion u, |
| }) : this( |
| u: u ?? $orig.u, |
| ); |
| |
| EmptyStructUnionStruct._(List<Object> argv) : u = argv[0]; |
| final EmptyStructUnion u; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| u, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'EmptyStructUnionStruct' r'(u: ' + u.toString() + r')'; |
| } |
| |
| static EmptyStructUnionStruct _ctor(List<Object> argv) => |
| EmptyStructUnionStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<EmptyStructUnionStruct> kEmptyStructUnionStruct_Type = |
| $fidl.StructType<EmptyStructUnionStruct>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<EmptyStructUnion>( |
| type: kEmptyStructUnion_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: EmptyStructUnionStruct._ctor, |
| ); |
| |
| class Size8Align8 extends $fidl.Struct { |
| const Size8Align8({ |
| @required this.data, |
| }); |
| Size8Align8.clone( |
| Size8Align8 $orig, { |
| int data, |
| }) : this( |
| data: data ?? $orig.data, |
| ); |
| |
| Size8Align8._(List<Object> argv) : data = argv[0]; |
| final int data; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| data, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Size8Align8' r'(data: ' + data.toString() + r')'; |
| } |
| |
| static Size8Align8 _ctor(List<Object> argv) => Size8Align8._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Size8Align8> kSize8Align8_Type = |
| $fidl.StructType<Size8Align8>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: Size8Align8._ctor, |
| ); |
| |
| class NoCodingTablesStressor extends $fidl.Struct { |
| const NoCodingTablesStressor({ |
| @required this.f1, |
| @required this.f2, |
| @required this.u1, |
| @required this.f3, |
| @required this.f4, |
| @required this.u2, |
| @required this.f5, |
| @required this.f6, |
| @required this.u3, |
| @required this.f7, |
| this.p1, |
| @required this.f8, |
| this.p2, |
| @required this.f9, |
| }); |
| NoCodingTablesStressor.clone( |
| NoCodingTablesStressor $orig, { |
| int f1, |
| int f2, |
| UnionSize36Align4 u1, |
| int f3, |
| int f4, |
| UnionSize36Align4 u2, |
| int f5, |
| int f6, |
| UnionSize36Align4 u3, |
| int f7, |
| Size8Align8 p1, |
| int f8, |
| Size8Align8 p2, |
| int f9, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| u1: u1 ?? $orig.u1, |
| f3: f3 ?? $orig.f3, |
| f4: f4 ?? $orig.f4, |
| u2: u2 ?? $orig.u2, |
| f5: f5 ?? $orig.f5, |
| f6: f6 ?? $orig.f6, |
| u3: u3 ?? $orig.u3, |
| f7: f7 ?? $orig.f7, |
| p1: p1 ?? $orig.p1, |
| f8: f8 ?? $orig.f8, |
| p2: p2 ?? $orig.p2, |
| f9: f9 ?? $orig.f9, |
| ); |
| |
| NoCodingTablesStressor.cloneWithout( |
| NoCodingTablesStressor $orig, { |
| bool p1, |
| bool p2, |
| }) : this( |
| f1: $orig.f1, |
| f2: $orig.f2, |
| u1: $orig.u1, |
| f3: $orig.f3, |
| f4: $orig.f4, |
| u2: $orig.u2, |
| f5: $orig.f5, |
| f6: $orig.f6, |
| u3: $orig.u3, |
| f7: $orig.f7, |
| p1: p1 ? null : $orig.p1, |
| f8: $orig.f8, |
| p2: p2 ? null : $orig.p2, |
| f9: $orig.f9, |
| ); |
| |
| NoCodingTablesStressor._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1], |
| u1 = argv[2], |
| f3 = argv[3], |
| f4 = argv[4], |
| u2 = argv[5], |
| f5 = argv[6], |
| f6 = argv[7], |
| u3 = argv[8], |
| f7 = argv[9], |
| p1 = argv[10], |
| f8 = argv[11], |
| p2 = argv[12], |
| f9 = argv[13]; |
| final int f1; |
| final int f2; |
| final UnionSize36Align4 u1; |
| final int f3; |
| final int f4; |
| final UnionSize36Align4 u2; |
| final int f5; |
| final int f6; |
| final UnionSize36Align4 u3; |
| final int f7; |
| final Size8Align8 p1; |
| final int f8; |
| final Size8Align8 p2; |
| final int f9; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| u1, |
| f3, |
| f4, |
| u2, |
| f5, |
| f6, |
| u3, |
| f7, |
| p1, |
| f8, |
| p2, |
| f9, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'NoCodingTablesStressor' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r', u1: ' + |
| u1.toString() + |
| r', f3: ' + |
| f3.toString() + |
| r', f4: ' + |
| f4.toString() + |
| r', u2: ' + |
| u2.toString() + |
| r', f5: ' + |
| f5.toString() + |
| r', f6: ' + |
| f6.toString() + |
| r', u3: ' + |
| u3.toString() + |
| r', f7: ' + |
| f7.toString() + |
| r', p1: ' + |
| p1.toString() + |
| r', f8: ' + |
| f8.toString() + |
| r', p2: ' + |
| p2.toString() + |
| r', f9: ' + |
| f9.toString() + |
| r')'; |
| } |
| |
| static NoCodingTablesStressor _ctor(List<Object> argv) => |
| NoCodingTablesStressor._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<NoCodingTablesStressor> kNoCodingTablesStressor_Type = |
| $fidl.StructType<NoCodingTablesStressor>( |
| inlineSizeOld: 208, |
| inlineSizeV1: 160, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint64Type(), offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<UnionSize36Align4>( |
| type: kUnionSize36Align4_Type, offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 56, offsetV1: 40), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 64, offsetV1: 48), |
| $fidl.MemberType<UnionSize36Align4>( |
| type: kUnionSize36Align4_Type, offsetOld: 72, offsetV1: 56), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 112, offsetV1: 80), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 120, offsetV1: 88), |
| $fidl.MemberType<UnionSize36Align4>( |
| type: kUnionSize36Align4_Type, offsetOld: 128, offsetV1: 96), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 168, offsetV1: 120), |
| $fidl.MemberType<Size8Align8>( |
| type: $fidl.PointerType<Size8Align8>(element: kSize8Align8_Type), |
| offsetOld: 176, |
| offsetV1: 128), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 184, offsetV1: 136), |
| $fidl.MemberType<Size8Align8>( |
| type: $fidl.PointerType<Size8Align8>(element: kSize8Align8_Type), |
| offsetOld: 192, |
| offsetV1: 144), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 200, offsetV1: 152), |
| ], |
| ctor: NoCodingTablesStressor._ctor, |
| ); |
| |
| class OutOfLineSandwich1 extends $fidl.Struct { |
| const OutOfLineSandwich1({ |
| @required this.before, |
| @required this.v, |
| @required this.after, |
| }); |
| OutOfLineSandwich1.clone( |
| OutOfLineSandwich1 $orig, { |
| String before, |
| List<Sandwich1> v, |
| String after, |
| }) : this( |
| before: before ?? $orig.before, |
| v: v ?? $orig.v, |
| after: after ?? $orig.after, |
| ); |
| |
| OutOfLineSandwich1._(List<Object> argv) |
| : before = argv[0], |
| v = argv[1], |
| after = argv[2]; |
| final String before; |
| final List<Sandwich1> v; |
| final String after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| v, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'OutOfLineSandwich1' r'(before: ' + |
| before.toString() + |
| r', v: ' + |
| v.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static OutOfLineSandwich1 _ctor(List<Object> argv) => |
| OutOfLineSandwich1._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<OutOfLineSandwich1> kOutOfLineSandwich1_Type = |
| $fidl.StructType<OutOfLineSandwich1>( |
| inlineSizeOld: 48, |
| inlineSizeV1: 48, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<List<Sandwich1>>( |
| type: $fidl.VectorType<List<Sandwich1>>( |
| element: kSandwich1_Type, maybeElementCount: 1, nullable: false), |
| offsetOld: 16, |
| offsetV1: 16), |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 32, |
| offsetV1: 32), |
| ], |
| ctor: OutOfLineSandwich1._ctor, |
| ); |
| |
| class OutOfLineSandwich1WithOptUnion extends $fidl.Struct { |
| const OutOfLineSandwich1WithOptUnion({ |
| @required this.before, |
| @required this.v, |
| @required this.after, |
| }); |
| OutOfLineSandwich1WithOptUnion.clone( |
| OutOfLineSandwich1WithOptUnion $orig, { |
| String before, |
| List<Sandwich1WithOptUnion> v, |
| String after, |
| }) : this( |
| before: before ?? $orig.before, |
| v: v ?? $orig.v, |
| after: after ?? $orig.after, |
| ); |
| |
| OutOfLineSandwich1WithOptUnion._(List<Object> argv) |
| : before = argv[0], |
| v = argv[1], |
| after = argv[2]; |
| final String before; |
| final List<Sandwich1WithOptUnion> v; |
| final String after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| v, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'OutOfLineSandwich1WithOptUnion' r'(before: ' + |
| before.toString() + |
| r', v: ' + |
| v.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static OutOfLineSandwich1WithOptUnion _ctor(List<Object> argv) => |
| OutOfLineSandwich1WithOptUnion._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<OutOfLineSandwich1WithOptUnion> |
| kOutOfLineSandwich1WithOptUnion_Type = |
| $fidl.StructType<OutOfLineSandwich1WithOptUnion>( |
| inlineSizeOld: 48, |
| inlineSizeV1: 48, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<List<Sandwich1WithOptUnion>>( |
| type: $fidl.VectorType<List<Sandwich1WithOptUnion>>( |
| element: kSandwich1WithOptUnion_Type, |
| maybeElementCount: 1, |
| nullable: false), |
| offsetOld: 16, |
| offsetV1: 16), |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 32, |
| offsetV1: 32), |
| ], |
| ctor: OutOfLineSandwich1WithOptUnion._ctor, |
| ); |
| |
| class Regression4 extends $fidl.Struct { |
| const Regression4({ |
| @required this.f1, |
| @required this.f2, |
| @required this.s1, |
| @required this.f3, |
| @required this.f4, |
| @required this.f5, |
| @required this.f6, |
| }); |
| Regression4.clone( |
| Regression4 $orig, { |
| int f1, |
| int f2, |
| StructSize3Align1 s1, |
| int f3, |
| int f4, |
| int f5, |
| int f6, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| s1: s1 ?? $orig.s1, |
| f3: f3 ?? $orig.f3, |
| f4: f4 ?? $orig.f4, |
| f5: f5 ?? $orig.f5, |
| f6: f6 ?? $orig.f6, |
| ); |
| |
| Regression4._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1], |
| s1 = argv[2], |
| f3 = argv[3], |
| f4 = argv[4], |
| f5 = argv[5], |
| f6 = argv[6]; |
| final int f1; |
| final int f2; |
| final StructSize3Align1 s1; |
| final int f3; |
| final int f4; |
| final int f5; |
| final int f6; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| s1, |
| f3, |
| f4, |
| f5, |
| f6, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression4' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r', s1: ' + |
| s1.toString() + |
| r', f3: ' + |
| f3.toString() + |
| r', f4: ' + |
| f4.toString() + |
| r', f5: ' + |
| f5.toString() + |
| r', f6: ' + |
| f6.toString() + |
| r')'; |
| } |
| |
| static Regression4 _ctor(List<Object> argv) => Regression4._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression4> kRegression4_Type = |
| $fidl.StructType<Regression4>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 32, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 4, offsetV1: 4), |
| $fidl.MemberType<StructSize3Align1>( |
| type: kStructSize3Align1_Type, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 11, offsetV1: 11), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint16Type(), offsetOld: 12, offsetV1: 12), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 24, offsetV1: 24), |
| ], |
| ctor: Regression4._ctor, |
| ); |
| |
| class Regression5 extends $fidl.Struct { |
| const Regression5({ |
| @required this.f1, |
| @required this.f2, |
| @required this.f3, |
| @required this.f4, |
| @required this.f5, |
| @required this.f6, |
| }); |
| Regression5.clone( |
| Regression5 $orig, { |
| int f1, |
| int f2, |
| int f3, |
| int f4, |
| int f5, |
| int f6, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| f3: f3 ?? $orig.f3, |
| f4: f4 ?? $orig.f4, |
| f5: f5 ?? $orig.f5, |
| f6: f6 ?? $orig.f6, |
| ); |
| |
| Regression5._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1], |
| f3 = argv[2], |
| f4 = argv[3], |
| f5 = argv[4], |
| f6 = argv[5]; |
| final int f1; |
| final int f2; |
| final int f3; |
| final int f4; |
| final int f5; |
| final int f6; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| f3, |
| f4, |
| f5, |
| f6, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression5' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r', f3: ' + |
| f3.toString() + |
| r', f4: ' + |
| f4.toString() + |
| r', f5: ' + |
| f5.toString() + |
| r', f6: ' + |
| f6.toString() + |
| r')'; |
| } |
| |
| static Regression5 _ctor(List<Object> argv) => Regression5._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression5> kRegression5_Type = |
| $fidl.StructType<Regression5>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 32, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 4, offsetV1: 4), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint16Type(), offsetOld: 10, offsetV1: 10), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 24, offsetV1: 24), |
| ], |
| ctor: Regression5._ctor, |
| ); |
| |
| class Regression6 extends $fidl.Struct { |
| const Regression6({ |
| @required this.f1, |
| @required this.f2, |
| @required this.f3, |
| @required this.f4, |
| @required this.f5, |
| @required this.f6, |
| }); |
| Regression6.clone( |
| Regression6 $orig, { |
| int f1, |
| int f2, |
| int f3, |
| int f4, |
| int f5, |
| int f6, |
| }) : this( |
| f1: f1 ?? $orig.f1, |
| f2: f2 ?? $orig.f2, |
| f3: f3 ?? $orig.f3, |
| f4: f4 ?? $orig.f4, |
| f5: f5 ?? $orig.f5, |
| f6: f6 ?? $orig.f6, |
| ); |
| |
| Regression6._(List<Object> argv) |
| : f1 = argv[0], |
| f2 = argv[1], |
| f3 = argv[2], |
| f4 = argv[3], |
| f5 = argv[4], |
| f6 = argv[5]; |
| final int f1; |
| final int f2; |
| final int f3; |
| final int f4; |
| final int f5; |
| final int f6; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| f1, |
| f2, |
| f3, |
| f4, |
| f5, |
| f6, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression6' r'(f1: ' + |
| f1.toString() + |
| r', f2: ' + |
| f2.toString() + |
| r', f3: ' + |
| f3.toString() + |
| r', f4: ' + |
| f4.toString() + |
| r', f5: ' + |
| f5.toString() + |
| r', f6: ' + |
| f6.toString() + |
| r')'; |
| } |
| |
| static Regression6 _ctor(List<Object> argv) => Regression6._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression6> kRegression6_Type = |
| $fidl.StructType<Regression6>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 32, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 4, offsetV1: 4), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint16Type(), offsetOld: 10, offsetV1: 10), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<int>(type: $fidl.Uint8Type(), offsetOld: 24, offsetV1: 24), |
| ], |
| ctor: Regression6._ctor, |
| ); |
| |
| class Regression7TableUnionXUnion extends $fidl.Struct { |
| const Regression7TableUnionXUnion({ |
| @required this.value, |
| }); |
| Regression7TableUnionXUnion.clone( |
| Regression7TableUnionXUnion $orig, { |
| TableOfUnionThenXUnionThenTableThenXUnionThenUnion value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| Regression7TableUnionXUnion._(List<Object> argv) : value = argv[0]; |
| final TableOfUnionThenXUnionThenTableThenXUnionThenUnion value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression7TableUnionXUnion' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static Regression7TableUnionXUnion _ctor(List<Object> argv) => |
| Regression7TableUnionXUnion._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression7TableUnionXUnion> |
| kRegression7TableUnionXUnion_Type = |
| $fidl.StructType<Regression7TableUnionXUnion>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableOfUnionThenXUnionThenTableThenXUnionThenUnion>( |
| type: kTableOfUnionThenXUnionThenTableThenXUnionThenUnion_Type, |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Regression7TableUnionXUnion._ctor, |
| ); |
| |
| class Regression8OptUnionSize12Align4 extends $fidl.Struct { |
| const Regression8OptUnionSize12Align4({ |
| this.optUnion1, |
| this.optUnion2, |
| this.optUnion3, |
| }); |
| Regression8OptUnionSize12Align4.clone( |
| Regression8OptUnionSize12Align4 $orig, { |
| UnionSize12Align4 optUnion1, |
| UnionSize12Align4 optUnion2, |
| UnionSize12Align4 optUnion3, |
| }) : this( |
| optUnion1: optUnion1 ?? $orig.optUnion1, |
| optUnion2: optUnion2 ?? $orig.optUnion2, |
| optUnion3: optUnion3 ?? $orig.optUnion3, |
| ); |
| |
| Regression8OptUnionSize12Align4.cloneWithout( |
| Regression8OptUnionSize12Align4 $orig, { |
| bool optUnion1, |
| bool optUnion2, |
| bool optUnion3, |
| }) : this( |
| optUnion1: optUnion1 ? null : $orig.optUnion1, |
| optUnion2: optUnion2 ? null : $orig.optUnion2, |
| optUnion3: optUnion3 ? null : $orig.optUnion3, |
| ); |
| |
| Regression8OptUnionSize12Align4._(List<Object> argv) |
| : optUnion1 = argv[0], |
| optUnion2 = argv[1], |
| optUnion3 = argv[2]; |
| final UnionSize12Align4 optUnion1; |
| final UnionSize12Align4 optUnion2; |
| final UnionSize12Align4 optUnion3; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| optUnion1, |
| optUnion2, |
| optUnion3, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression8OptUnionSize12Align4' r'(optUnion1: ' + |
| optUnion1.toString() + |
| r', optUnion2: ' + |
| optUnion2.toString() + |
| r', optUnion3: ' + |
| optUnion3.toString() + |
| r')'; |
| } |
| |
| static Regression8OptUnionSize12Align4 _ctor(List<Object> argv) => |
| Regression8OptUnionSize12Align4._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression8OptUnionSize12Align4> |
| kRegression8OptUnionSize12Align4_Type = |
| $fidl.StructType<Regression8OptUnionSize12Align4>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 72, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<UnionSize12Align4>( |
| type: kUnionSize12Align4_OptType, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionSize12Align4>( |
| type: kUnionSize12Align4_OptType, offsetOld: 8, offsetV1: 24), |
| $fidl.MemberType<UnionSize12Align4>( |
| type: kUnionSize12Align4_OptType, offsetOld: 16, offsetV1: 48), |
| ], |
| ctor: Regression8OptUnionSize12Align4._ctor, |
| ); |
| |
| class Regression8VectorOfOptUnionSize12Align4 extends $fidl.Struct { |
| const Regression8VectorOfOptUnionSize12Align4({ |
| @required this.value, |
| }); |
| Regression8VectorOfOptUnionSize12Align4.clone( |
| Regression8VectorOfOptUnionSize12Align4 $orig, { |
| List<UnionSize12Align4> value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| Regression8VectorOfOptUnionSize12Align4._(List<Object> argv) |
| : value = argv[0]; |
| final List<UnionSize12Align4> value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression8VectorOfOptUnionSize12Align4' r'(value: ' + |
| value.toString() + |
| r')'; |
| } |
| |
| static Regression8VectorOfOptUnionSize12Align4 _ctor(List<Object> argv) => |
| Regression8VectorOfOptUnionSize12Align4._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression8VectorOfOptUnionSize12Align4> |
| kRegression8VectorOfOptUnionSize12Align4_Type = |
| $fidl.StructType<Regression8VectorOfOptUnionSize12Align4>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<UnionSize12Align4>>( |
| type: $fidl.VectorType<List<UnionSize12Align4>>( |
| element: kUnionSize12Align4_OptType, |
| maybeElementCount: null, |
| nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: Regression8VectorOfOptUnionSize12Align4._ctor, |
| ); |
| |
| class Regression8TableWithUnionSize12Align4 extends $fidl.Struct { |
| const Regression8TableWithUnionSize12Align4({ |
| @required this.value, |
| }); |
| Regression8TableWithUnionSize12Align4.clone( |
| Regression8TableWithUnionSize12Align4 $orig, { |
| TableWithUnionSize12Align4 value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| Regression8TableWithUnionSize12Align4._(List<Object> argv) : value = argv[0]; |
| final TableWithUnionSize12Align4 value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression8TableWithUnionSize12Align4' r'(value: ' + |
| value.toString() + |
| r')'; |
| } |
| |
| static Regression8TableWithUnionSize12Align4 _ctor(List<Object> argv) => |
| Regression8TableWithUnionSize12Align4._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression8TableWithUnionSize12Align4> |
| kRegression8TableWithUnionSize12Align4_Type = |
| $fidl.StructType<Regression8TableWithUnionSize12Align4>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableWithUnionSize12Align4>( |
| type: kTableWithUnionSize12Align4_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: Regression8TableWithUnionSize12Align4._ctor, |
| ); |
| |
| class StringUnionStruct extends $fidl.Struct { |
| const StringUnionStruct({ |
| @required this.u, |
| this.nullableU, |
| }); |
| StringUnionStruct.clone( |
| StringUnionStruct $orig, { |
| StringBoolUnion u, |
| StringBoolUnion nullableU, |
| }) : this( |
| u: u ?? $orig.u, |
| nullableU: nullableU ?? $orig.nullableU, |
| ); |
| |
| StringUnionStruct.cloneWithout( |
| StringUnionStruct $orig, { |
| bool nullableU, |
| }) : this( |
| u: $orig.u, |
| nullableU: nullableU ? null : $orig.nullableU, |
| ); |
| |
| StringUnionStruct._(List<Object> argv) |
| : u = argv[0], |
| nullableU = argv[1]; |
| final StringBoolUnion u; |
| final StringBoolUnion nullableU; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| u, |
| nullableU, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StringUnionStruct' r'(u: ' + |
| u.toString() + |
| r', nullableU: ' + |
| nullableU.toString() + |
| r')'; |
| } |
| |
| static StringUnionStruct _ctor(List<Object> argv) => |
| StringUnionStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StringUnionStruct> kStringUnionStruct_Type = |
| $fidl.StructType<StringUnionStruct>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 48, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<StringBoolUnion>( |
| type: kStringBoolUnion_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<StringBoolUnion>( |
| type: kStringBoolUnion_OptType, offsetOld: 24, offsetV1: 24), |
| ], |
| ctor: StringUnionStruct._ctor, |
| ); |
| |
| class StringUnionStructWrapper extends $fidl.Struct { |
| const StringUnionStructWrapper({ |
| @required this.sus, |
| }); |
| StringUnionStructWrapper.clone( |
| StringUnionStructWrapper $orig, { |
| StringUnionStruct sus, |
| }) : this( |
| sus: sus ?? $orig.sus, |
| ); |
| |
| StringUnionStructWrapper._(List<Object> argv) : sus = argv[0]; |
| final StringUnionStruct sus; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| sus, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StringUnionStructWrapper' r'(sus: ' + sus.toString() + r')'; |
| } |
| |
| static StringUnionStructWrapper _ctor(List<Object> argv) => |
| StringUnionStructWrapper._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StringUnionStructWrapper> |
| kStringUnionStructWrapper_Type = $fidl.StructType<StringUnionStructWrapper>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 48, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<StringUnionStruct>( |
| type: kStringUnionStruct_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StringUnionStructWrapper._ctor, |
| ); |
| |
| class StringUnionStructWrapperResponse extends $fidl.Struct { |
| const StringUnionStructWrapperResponse({ |
| @required this.header, |
| @required this.body, |
| }); |
| StringUnionStructWrapperResponse.clone( |
| StringUnionStructWrapperResponse $orig, { |
| TransactionHeader header, |
| StringUnionStructWrapper body, |
| }) : this( |
| header: header ?? $orig.header, |
| body: body ?? $orig.body, |
| ); |
| |
| StringUnionStructWrapperResponse._(List<Object> argv) |
| : header = argv[0], |
| body = argv[1]; |
| final TransactionHeader header; |
| final StringUnionStructWrapper body; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| header, |
| body, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StringUnionStructWrapperResponse' r'(header: ' + |
| header.toString() + |
| r', body: ' + |
| body.toString() + |
| r')'; |
| } |
| |
| static StringUnionStructWrapperResponse _ctor(List<Object> argv) => |
| StringUnionStructWrapperResponse._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StringUnionStructWrapperResponse> |
| kStringUnionStructWrapperResponse_Type = |
| $fidl.StructType<StringUnionStructWrapperResponse>( |
| inlineSizeOld: 48, |
| inlineSizeV1: 64, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TransactionHeader>( |
| type: kTransactionHeader_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<StringUnionStructWrapper>( |
| type: kStringUnionStructWrapper_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: StringUnionStructWrapperResponse._ctor, |
| ); |
| |
| class Regression9Value extends $fidl.Struct { |
| const Regression9Value({ |
| @required this.u, |
| this.nullableU, |
| }); |
| Regression9Value.clone( |
| Regression9Value $orig, { |
| StringBoolUnion u, |
| StringBoolUnion nullableU, |
| }) : this( |
| u: u ?? $orig.u, |
| nullableU: nullableU ?? $orig.nullableU, |
| ); |
| |
| Regression9Value.cloneWithout( |
| Regression9Value $orig, { |
| bool nullableU, |
| }) : this( |
| u: $orig.u, |
| nullableU: nullableU ? null : $orig.nullableU, |
| ); |
| |
| Regression9Value._(List<Object> argv) |
| : u = argv[0], |
| nullableU = argv[1]; |
| final StringBoolUnion u; |
| final StringBoolUnion nullableU; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| u, |
| nullableU, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression9Value' r'(u: ' + |
| u.toString() + |
| r', nullableU: ' + |
| nullableU.toString() + |
| r')'; |
| } |
| |
| static Regression9Value _ctor(List<Object> argv) => Regression9Value._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression9Value> kRegression9Value_Type = |
| $fidl.StructType<Regression9Value>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 48, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<StringBoolUnion>( |
| type: kStringBoolUnion_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<StringBoolUnion>( |
| type: kStringBoolUnion_OptType, offsetOld: 24, offsetV1: 24), |
| ], |
| ctor: Regression9Value._ctor, |
| ); |
| |
| class Regression9Message extends $fidl.Struct { |
| const Regression9Message({ |
| @required this.header, |
| @required this.body, |
| }); |
| Regression9Message.clone( |
| Regression9Message $orig, { |
| TransactionHeader header, |
| Regression9Result body, |
| }) : this( |
| header: header ?? $orig.header, |
| body: body ?? $orig.body, |
| ); |
| |
| Regression9Message._(List<Object> argv) |
| : header = argv[0], |
| body = argv[1]; |
| final TransactionHeader header; |
| final Regression9Result body; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| header, |
| body, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression9Message' r'(header: ' + |
| header.toString() + |
| r', body: ' + |
| body.toString() + |
| r')'; |
| } |
| |
| static Regression9Message _ctor(List<Object> argv) => |
| Regression9Message._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression9Message> kRegression9Message_Type = |
| $fidl.StructType<Regression9Message>( |
| inlineSizeOld: 56, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TransactionHeader>( |
| type: kTransactionHeader_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Regression9Result>( |
| type: kRegression9Result_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: Regression9Message._ctor, |
| ); |
| |
| class Regression10V1 extends $fidl.Struct { |
| const Regression10V1({ |
| @required this.table, |
| }); |
| Regression10V1.clone( |
| Regression10V1 $orig, { |
| Regression10TableV1 table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| Regression10V1._(List<Object> argv) : table = argv[0]; |
| final Regression10TableV1 table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression10V1' r'(table: ' + table.toString() + r')'; |
| } |
| |
| static Regression10V1 _ctor(List<Object> argv) => Regression10V1._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression10V1> kRegression10V1_Type = |
| $fidl.StructType<Regression10V1>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Regression10TableV1>( |
| type: kRegression10TableV1_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: Regression10V1._ctor, |
| ); |
| |
| class Regression10V2 extends $fidl.Struct { |
| const Regression10V2({ |
| @required this.table, |
| }); |
| Regression10V2.clone( |
| Regression10V2 $orig, { |
| Regression10TableV2 table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| Regression10V2._(List<Object> argv) : table = argv[0]; |
| final Regression10TableV2 table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression10V2' r'(table: ' + table.toString() + r')'; |
| } |
| |
| static Regression10V2 _ctor(List<Object> argv) => Regression10V2._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression10V2> kRegression10V2_Type = |
| $fidl.StructType<Regression10V2>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Regression10TableV2>( |
| type: kRegression10TableV2_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: Regression10V2._ctor, |
| ); |
| |
| class Regression10V3 extends $fidl.Struct { |
| const Regression10V3({ |
| @required this.table, |
| }); |
| Regression10V3.clone( |
| Regression10V3 $orig, { |
| Regression10TableV3 table, |
| }) : this( |
| table: table ?? $orig.table, |
| ); |
| |
| Regression10V3._(List<Object> argv) : table = argv[0]; |
| final Regression10TableV3 table; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| table, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression10V3' r'(table: ' + table.toString() + r')'; |
| } |
| |
| static Regression10V3 _ctor(List<Object> argv) => Regression10V3._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression10V3> kRegression10V3_Type = |
| $fidl.StructType<Regression10V3>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Regression10TableV3>( |
| type: kRegression10TableV3_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: Regression10V3._ctor, |
| ); |
| |
| class Regression11 extends $fidl.Struct { |
| const Regression11({ |
| @required this.tableOfTable, |
| }); |
| Regression11.clone( |
| Regression11 $orig, { |
| UnionWithRegression10Table tableOfTable, |
| }) : this( |
| tableOfTable: tableOfTable ?? $orig.tableOfTable, |
| ); |
| |
| Regression11._(List<Object> argv) : tableOfTable = argv[0]; |
| final UnionWithRegression10Table tableOfTable; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| tableOfTable, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Regression11' r'(tableOfTable: ' + tableOfTable.toString() + r')'; |
| } |
| |
| static Regression11 _ctor(List<Object> argv) => Regression11._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Regression11> kRegression11_Type = |
| $fidl.StructType<Regression11>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<UnionWithRegression10Table>( |
| type: kUnionWithRegression10Table_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: Regression11._ctor, |
| ); |
| |
| class Sandwich4Align8 extends $fidl.Struct { |
| const Sandwich4Align8({ |
| @required this.sandwich4, |
| @required this.alignment8Enforcement, |
| }); |
| Sandwich4Align8.clone( |
| Sandwich4Align8 $orig, { |
| Sandwich4 sandwich4, |
| int alignment8Enforcement, |
| }) : this( |
| sandwich4: sandwich4 ?? $orig.sandwich4, |
| alignment8Enforcement: |
| alignment8Enforcement ?? $orig.alignment8Enforcement, |
| ); |
| |
| Sandwich4Align8._(List<Object> argv) |
| : sandwich4 = argv[0], |
| alignment8Enforcement = argv[1]; |
| final Sandwich4 sandwich4; |
| final int alignment8Enforcement; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| sandwich4, |
| alignment8Enforcement, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich4Align8' r'(sandwich4: ' + |
| sandwich4.toString() + |
| r', alignment8Enforcement: ' + |
| alignment8Enforcement.toString() + |
| r')'; |
| } |
| |
| static Sandwich4Align8 _ctor(List<Object> argv) => Sandwich4Align8._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich4Align8> kSandwich4Align8_Type = |
| $fidl.StructType<Sandwich4Align8>( |
| inlineSizeOld: 56, |
| inlineSizeV1: 48, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Sandwich4>( |
| type: kSandwich4_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 48, offsetV1: 40), |
| ], |
| ctor: Sandwich4Align8._ctor, |
| ); |
| |
| class Sandwich4Align8WithPointer extends $fidl.Struct { |
| const Sandwich4Align8WithPointer({ |
| @required this.sandwich4, |
| this.alignment8Enforcement, |
| }); |
| Sandwich4Align8WithPointer.clone( |
| Sandwich4Align8WithPointer $orig, { |
| Sandwich4 sandwich4, |
| Size8Align8 alignment8Enforcement, |
| }) : this( |
| sandwich4: sandwich4 ?? $orig.sandwich4, |
| alignment8Enforcement: |
| alignment8Enforcement ?? $orig.alignment8Enforcement, |
| ); |
| |
| Sandwich4Align8WithPointer.cloneWithout( |
| Sandwich4Align8WithPointer $orig, { |
| bool alignment8Enforcement, |
| }) : this( |
| sandwich4: $orig.sandwich4, |
| alignment8Enforcement: |
| alignment8Enforcement ? null : $orig.alignment8Enforcement, |
| ); |
| |
| Sandwich4Align8WithPointer._(List<Object> argv) |
| : sandwich4 = argv[0], |
| alignment8Enforcement = argv[1]; |
| final Sandwich4 sandwich4; |
| final Size8Align8 alignment8Enforcement; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| sandwich4, |
| alignment8Enforcement, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich4Align8WithPointer' r'(sandwich4: ' + |
| sandwich4.toString() + |
| r', alignment8Enforcement: ' + |
| alignment8Enforcement.toString() + |
| r')'; |
| } |
| |
| static Sandwich4Align8WithPointer _ctor(List<Object> argv) => |
| Sandwich4Align8WithPointer._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich4Align8WithPointer> |
| kSandwich4Align8WithPointer_Type = |
| $fidl.StructType<Sandwich4Align8WithPointer>( |
| inlineSizeOld: 56, |
| inlineSizeV1: 48, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<Sandwich4>( |
| type: kSandwich4_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<Size8Align8>( |
| type: $fidl.PointerType<Size8Align8>(element: kSize8Align8_Type), |
| offsetOld: 48, |
| offsetV1: 40), |
| ], |
| ctor: Sandwich4Align8WithPointer._ctor, |
| ); |
| |
| class Sandwich9 extends $fidl.Struct { |
| const Sandwich9({ |
| @required this.before, |
| @required this.theUnion, |
| @required this.after, |
| }); |
| Sandwich9.clone( |
| Sandwich9 $orig, { |
| int before, |
| UnionWithVectorOfVectors theUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| theUnion: theUnion ?? $orig.theUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| Sandwich9._(List<Object> argv) |
| : before = argv[0], |
| theUnion = argv[1], |
| after = argv[2]; |
| final int before; |
| final UnionWithVectorOfVectors theUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| theUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Sandwich9' r'(before: ' + |
| before.toString() + |
| r', theUnion: ' + |
| theUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static Sandwich9 _ctor(List<Object> argv) => Sandwich9._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Sandwich9> kSandwich9_Type = $fidl.StructType<Sandwich9>( |
| inlineSizeOld: 40, |
| inlineSizeV1: 40, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint16Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionWithVectorOfVectors>( |
| type: kUnionWithVectorOfVectors_Type, offsetOld: 8, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint16Type(), offsetOld: 32, offsetV1: 32), |
| ], |
| ctor: Sandwich9._ctor, |
| ); |
| |
| class SimpleTableArrayStruct extends $fidl.Struct { |
| const SimpleTableArrayStruct({ |
| @required this.theArray, |
| }); |
| SimpleTableArrayStruct.clone( |
| SimpleTableArrayStruct $orig, { |
| List<TransformerSimpleTable> theArray, |
| }) : this( |
| theArray: theArray ?? $orig.theArray, |
| ); |
| |
| SimpleTableArrayStruct._(List<Object> argv) : theArray = argv[0]; |
| final List<TransformerSimpleTable> theArray; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| theArray, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'SimpleTableArrayStruct' r'(theArray: ' + |
| theArray.toString() + |
| r')'; |
| } |
| |
| static SimpleTableArrayStruct _ctor(List<Object> argv) => |
| SimpleTableArrayStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<SimpleTableArrayStruct> kSimpleTableArrayStruct_Type = |
| $fidl.StructType<SimpleTableArrayStruct>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 32, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<TransformerSimpleTable>>( |
| type: $fidl.ArrayType<List<TransformerSimpleTable>>( |
| element: kTransformerSimpleTable_Type, elementCount: 2), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: SimpleTableArrayStruct._ctor, |
| ); |
| |
| class StringUnionVector extends $fidl.Struct { |
| const StringUnionVector({ |
| @required this.theVector, |
| }); |
| StringUnionVector.clone( |
| StringUnionVector $orig, { |
| List<StringUnion> theVector, |
| }) : this( |
| theVector: theVector ?? $orig.theVector, |
| ); |
| |
| StringUnionVector._(List<Object> argv) : theVector = argv[0]; |
| final List<StringUnion> theVector; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| theVector, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StringUnionVector' r'(theVector: ' + theVector.toString() + r')'; |
| } |
| |
| static StringUnionVector _ctor(List<Object> argv) => |
| StringUnionVector._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StringUnionVector> kStringUnionVector_Type = |
| $fidl.StructType<StringUnionVector>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<List<StringUnion>>( |
| type: $fidl.VectorType<List<StringUnion>>( |
| element: kStringUnion_OptType, |
| maybeElementCount: 3, |
| nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| ], |
| ctor: StringUnionVector._ctor, |
| ); |
| |
| class LaunchInfo extends $fidl.Struct { |
| const LaunchInfo({ |
| @required this.url, |
| this.arguments, |
| this.out, |
| this.err, |
| @required this.directoryRequest, |
| this.flatNamespace, |
| this.additionalServices, |
| }); |
| LaunchInfo.clone( |
| LaunchInfo $orig, { |
| String url, |
| List<String> arguments, |
| TransformerEmptyStruct out, |
| TransformerEmptyStruct err, |
| int directoryRequest, |
| TransformerEmptyStruct flatNamespace, |
| TransformerEmptyStruct additionalServices, |
| }) : this( |
| url: url ?? $orig.url, |
| arguments: arguments ?? $orig.arguments, |
| out: out ?? $orig.out, |
| err: err ?? $orig.err, |
| directoryRequest: directoryRequest ?? $orig.directoryRequest, |
| flatNamespace: flatNamespace ?? $orig.flatNamespace, |
| additionalServices: additionalServices ?? $orig.additionalServices, |
| ); |
| |
| LaunchInfo.cloneWithout( |
| LaunchInfo $orig, { |
| bool arguments, |
| bool out, |
| bool err, |
| bool flatNamespace, |
| bool additionalServices, |
| }) : this( |
| url: $orig.url, |
| arguments: arguments ? null : $orig.arguments, |
| out: out ? null : $orig.out, |
| err: err ? null : $orig.err, |
| directoryRequest: $orig.directoryRequest, |
| flatNamespace: flatNamespace ? null : $orig.flatNamespace, |
| additionalServices: |
| additionalServices ? null : $orig.additionalServices, |
| ); |
| |
| LaunchInfo._(List<Object> argv) |
| : url = argv[0], |
| arguments = argv[1], |
| out = argv[2], |
| err = argv[3], |
| directoryRequest = argv[4], |
| flatNamespace = argv[5], |
| additionalServices = argv[6]; |
| final String url; |
| final List<String> arguments; |
| final TransformerEmptyStruct out; |
| final TransformerEmptyStruct err; |
| final int directoryRequest; |
| final TransformerEmptyStruct flatNamespace; |
| final TransformerEmptyStruct additionalServices; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| url, |
| arguments, |
| out, |
| err, |
| directoryRequest, |
| flatNamespace, |
| additionalServices, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'LaunchInfo' r'(url: ' + |
| url.toString() + |
| r', arguments: ' + |
| arguments.toString() + |
| r', out: ' + |
| out.toString() + |
| r', err: ' + |
| err.toString() + |
| r', directoryRequest: ' + |
| directoryRequest.toString() + |
| r', flatNamespace: ' + |
| flatNamespace.toString() + |
| r', additionalServices: ' + |
| additionalServices.toString() + |
| r')'; |
| } |
| |
| static LaunchInfo _ctor(List<Object> argv) => LaunchInfo._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<LaunchInfo> kLaunchInfo_Type = |
| $fidl.StructType<LaunchInfo>( |
| inlineSizeOld: 72, |
| inlineSizeV1: 72, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: 200, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<List<String>>( |
| type: $fidl.VectorType<List<String>>( |
| element: $fidl.StringType(maybeElementCount: null, nullable: false), |
| maybeElementCount: null, |
| nullable: true), |
| offsetOld: 16, |
| offsetV1: 16), |
| $fidl.MemberType<TransformerEmptyStruct>( |
| type: $fidl.PointerType<TransformerEmptyStruct>( |
| element: kTransformerEmptyStruct_Type), |
| offsetOld: 32, |
| offsetV1: 32), |
| $fidl.MemberType<TransformerEmptyStruct>( |
| type: $fidl.PointerType<TransformerEmptyStruct>( |
| element: kTransformerEmptyStruct_Type), |
| offsetOld: 40, |
| offsetV1: 40), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 48, offsetV1: 48), |
| $fidl.MemberType<TransformerEmptyStruct>( |
| type: $fidl.PointerType<TransformerEmptyStruct>( |
| element: kTransformerEmptyStruct_Type), |
| offsetOld: 56, |
| offsetV1: 56), |
| $fidl.MemberType<TransformerEmptyStruct>( |
| type: $fidl.PointerType<TransformerEmptyStruct>( |
| element: kTransformerEmptyStruct_Type), |
| offsetOld: 64, |
| offsetV1: 64), |
| ], |
| ctor: LaunchInfo._ctor, |
| ); |
| |
| class CreateComponentRequest extends $fidl.Struct { |
| const CreateComponentRequest({ |
| @required this.launchInfo, |
| @required this.controller, |
| }); |
| CreateComponentRequest.clone( |
| CreateComponentRequest $orig, { |
| LaunchInfo launchInfo, |
| int controller, |
| }) : this( |
| launchInfo: launchInfo ?? $orig.launchInfo, |
| controller: controller ?? $orig.controller, |
| ); |
| |
| CreateComponentRequest._(List<Object> argv) |
| : launchInfo = argv[0], |
| controller = argv[1]; |
| final LaunchInfo launchInfo; |
| final int controller; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| launchInfo, |
| controller, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'CreateComponentRequest' r'(launchInfo: ' + |
| launchInfo.toString() + |
| r', controller: ' + |
| controller.toString() + |
| r')'; |
| } |
| |
| static CreateComponentRequest _ctor(List<Object> argv) => |
| CreateComponentRequest._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<CreateComponentRequest> kCreateComponentRequest_Type = |
| $fidl.StructType<CreateComponentRequest>( |
| inlineSizeOld: 80, |
| inlineSizeV1: 80, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<LaunchInfo>( |
| type: kLaunchInfo_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 72, offsetV1: 72), |
| ], |
| ctor: CreateComponentRequest._ctor, |
| ); |
| |
| class CompatTable extends $fidl.Struct { |
| const CompatTable({ |
| @required this.value, |
| @required this.empty, |
| }); |
| CompatTable.clone( |
| CompatTable $orig, { |
| CompatTableValue value, |
| String empty, |
| }) : this( |
| value: value ?? $orig.value, |
| empty: empty ?? $orig.empty, |
| ); |
| |
| CompatTable._(List<Object> argv) |
| : value = argv[0], |
| empty = argv[1]; |
| final CompatTableValue value; |
| final String empty; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| empty, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'CompatTable' r'(value: ' + |
| value.toString() + |
| r', empty: ' + |
| empty.toString() + |
| r')'; |
| } |
| |
| static CompatTable _ctor(List<Object> argv) => CompatTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<CompatTable> kCompatTable_Type = |
| $fidl.StructType<CompatTable>( |
| inlineSizeOld: 32, |
| inlineSizeV1: 32, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<CompatTableValue>( |
| type: kCompatTableValue_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 16, |
| offsetV1: 16), |
| ], |
| ctor: CompatTable._ctor, |
| ); |
| |
| class MixedFieldsBody extends $fidl.Struct { |
| const MixedFieldsBody({ |
| @required this.before, |
| @required this.firstUnion, |
| @required this.middleStart, |
| @required this.middleEnd, |
| @required this.secondUnion, |
| @required this.after, |
| }); |
| MixedFieldsBody.clone( |
| MixedFieldsBody $orig, { |
| int before, |
| UnionSize8Align4 firstUnion, |
| int middleStart, |
| int middleEnd, |
| UnionSize8Align4 secondUnion, |
| int after, |
| }) : this( |
| before: before ?? $orig.before, |
| firstUnion: firstUnion ?? $orig.firstUnion, |
| middleStart: middleStart ?? $orig.middleStart, |
| middleEnd: middleEnd ?? $orig.middleEnd, |
| secondUnion: secondUnion ?? $orig.secondUnion, |
| after: after ?? $orig.after, |
| ); |
| |
| MixedFieldsBody._(List<Object> argv) |
| : before = argv[0], |
| firstUnion = argv[1], |
| middleStart = argv[2], |
| middleEnd = argv[3], |
| secondUnion = argv[4], |
| after = argv[5]; |
| final int before; |
| final UnionSize8Align4 firstUnion; |
| final int middleStart; |
| final int middleEnd; |
| final UnionSize8Align4 secondUnion; |
| final int after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| firstUnion, |
| middleStart, |
| middleEnd, |
| secondUnion, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MixedFieldsBody' r'(before: ' + |
| before.toString() + |
| r', firstUnion: ' + |
| firstUnion.toString() + |
| r', middleStart: ' + |
| middleStart.toString() + |
| r', middleEnd: ' + |
| middleEnd.toString() + |
| r', secondUnion: ' + |
| secondUnion.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static MixedFieldsBody _ctor(List<Object> argv) => MixedFieldsBody._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MixedFieldsBody> kMixedFieldsBody_Type = |
| $fidl.StructType<MixedFieldsBody>( |
| inlineSizeOld: 40, |
| inlineSizeV1: 80, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Uint32Type(), offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<UnionSize8Align4>( |
| type: kUnionSize8Align4_Type, offsetOld: 4, offsetV1: 8), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint16Type(), offsetOld: 12, offsetV1: 32), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint64Type(), offsetOld: 16, offsetV1: 40), |
| $fidl.MemberType<UnionSize8Align4>( |
| type: kUnionSize8Align4_Type, offsetOld: 24, offsetV1: 48), |
| $fidl.MemberType<int>( |
| type: $fidl.Uint32Type(), offsetOld: 32, offsetV1: 72), |
| ], |
| ctor: MixedFieldsBody._ctor, |
| ); |
| |
| class MixedFieldsMessage extends $fidl.Struct { |
| const MixedFieldsMessage({ |
| @required this.header, |
| @required this.body, |
| }); |
| MixedFieldsMessage.clone( |
| MixedFieldsMessage $orig, { |
| TransactionHeader header, |
| MixedFieldsBody body, |
| }) : this( |
| header: header ?? $orig.header, |
| body: body ?? $orig.body, |
| ); |
| |
| MixedFieldsMessage._(List<Object> argv) |
| : header = argv[0], |
| body = argv[1]; |
| final TransactionHeader header; |
| final MixedFieldsBody body; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| header, |
| body, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'MixedFieldsMessage' r'(header: ' + |
| header.toString() + |
| r', body: ' + |
| body.toString() + |
| r')'; |
| } |
| |
| static MixedFieldsMessage _ctor(List<Object> argv) => |
| MixedFieldsMessage._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<MixedFieldsMessage> kMixedFieldsMessage_Type = |
| $fidl.StructType<MixedFieldsMessage>( |
| inlineSizeOld: 56, |
| inlineSizeV1: 96, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TransactionHeader>( |
| type: kTransactionHeader_Type, offsetOld: 0, offsetV1: 0), |
| $fidl.MemberType<MixedFieldsBody>( |
| type: kMixedFieldsBody_Type, offsetOld: 16, offsetV1: 16), |
| ], |
| ctor: MixedFieldsMessage._ctor, |
| ); |
| |
| class StructOfTableWithXUnion extends $fidl.Struct { |
| const StructOfTableWithXUnion({ |
| @required this.value, |
| }); |
| StructOfTableWithXUnion.clone( |
| StructOfTableWithXUnion $orig, { |
| TableWithXUnion value, |
| }) : this( |
| value: value ?? $orig.value, |
| ); |
| |
| StructOfTableWithXUnion._(List<Object> argv) : value = argv[0]; |
| final TableWithXUnion value; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| value, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'StructOfTableWithXUnion' r'(value: ' + value.toString() + r')'; |
| } |
| |
| static StructOfTableWithXUnion _ctor(List<Object> argv) => |
| StructOfTableWithXUnion._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<StructOfTableWithXUnion> kStructOfTableWithXUnion_Type = |
| $fidl.StructType<StructOfTableWithXUnion>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<TableWithXUnion>( |
| type: kTableWithXUnion_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: StructOfTableWithXUnion._ctor, |
| ); |
| |
| class Int64Struct extends $fidl.Struct { |
| const Int64Struct({ |
| @required this.x, |
| }); |
| Int64Struct.clone( |
| Int64Struct $orig, { |
| int x, |
| }) : this( |
| x: x ?? $orig.x, |
| ); |
| |
| Int64Struct._(List<Object> argv) : x = argv[0]; |
| final int x; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| x, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'Int64Struct' r'(x: ' + x.toString() + r')'; |
| } |
| |
| static Int64Struct _ctor(List<Object> argv) => Int64Struct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<Int64Struct> kInt64Struct_Type = |
| $fidl.StructType<Int64Struct>( |
| inlineSizeOld: 8, |
| inlineSizeV1: 8, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<int>(type: $fidl.Int64Type(), offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: Int64Struct._ctor, |
| ); |
| |
| class TestInlineXUnionInStruct extends $fidl.Struct { |
| const TestInlineXUnionInStruct({ |
| @required this.before, |
| @required this.xu, |
| @required this.after, |
| }); |
| TestInlineXUnionInStruct.clone( |
| TestInlineXUnionInStruct $orig, { |
| String before, |
| SampleXUnion xu, |
| String after, |
| }) : this( |
| before: before ?? $orig.before, |
| xu: xu ?? $orig.xu, |
| after: after ?? $orig.after, |
| ); |
| |
| TestInlineXUnionInStruct._(List<Object> argv) |
| : before = argv[0], |
| xu = argv[1], |
| after = argv[2]; |
| final String before; |
| final SampleXUnion xu; |
| final String after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| xu, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TestInlineXUnionInStruct' r'(before: ' + |
| before.toString() + |
| r', xu: ' + |
| xu.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static TestInlineXUnionInStruct _ctor(List<Object> argv) => |
| TestInlineXUnionInStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TestInlineXUnionInStruct> |
| kTestInlineXUnionInStruct_Type = $fidl.StructType<TestInlineXUnionInStruct>( |
| inlineSizeOld: 56, |
| inlineSizeV1: 56, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<SampleXUnion>( |
| type: kSampleXUnion_Type, offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 40, |
| offsetV1: 40), |
| ], |
| ctor: TestInlineXUnionInStruct._ctor, |
| ); |
| |
| class TestOptionalXUnionInStruct extends $fidl.Struct { |
| const TestOptionalXUnionInStruct({ |
| @required this.before, |
| this.xu, |
| @required this.after, |
| }); |
| TestOptionalXUnionInStruct.clone( |
| TestOptionalXUnionInStruct $orig, { |
| String before, |
| SampleXUnion xu, |
| String after, |
| }) : this( |
| before: before ?? $orig.before, |
| xu: xu ?? $orig.xu, |
| after: after ?? $orig.after, |
| ); |
| |
| TestOptionalXUnionInStruct.cloneWithout( |
| TestOptionalXUnionInStruct $orig, { |
| bool xu, |
| }) : this( |
| before: $orig.before, |
| xu: xu ? null : $orig.xu, |
| after: $orig.after, |
| ); |
| |
| TestOptionalXUnionInStruct._(List<Object> argv) |
| : before = argv[0], |
| xu = argv[1], |
| after = argv[2]; |
| final String before; |
| final SampleXUnion xu; |
| final String after; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| before, |
| xu, |
| after, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TestOptionalXUnionInStruct' r'(before: ' + |
| before.toString() + |
| r', xu: ' + |
| xu.toString() + |
| r', after: ' + |
| after.toString() + |
| r')'; |
| } |
| |
| static TestOptionalXUnionInStruct _ctor(List<Object> argv) => |
| TestOptionalXUnionInStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TestOptionalXUnionInStruct> |
| kTestOptionalXUnionInStruct_Type = |
| $fidl.StructType<TestOptionalXUnionInStruct>( |
| inlineSizeOld: 56, |
| inlineSizeV1: 56, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 0, |
| offsetV1: 0), |
| $fidl.MemberType<SampleXUnion>( |
| type: kSampleXUnion_OptType, offsetOld: 16, offsetV1: 16), |
| $fidl.MemberType<String>( |
| type: $fidl.StringType(maybeElementCount: null, nullable: false), |
| offsetOld: 40, |
| offsetV1: 40), |
| ], |
| ctor: TestOptionalXUnionInStruct._ctor, |
| ); |
| |
| class TestStrictXUnionInStruct extends $fidl.Struct { |
| const TestStrictXUnionInStruct({ |
| @required this.xu, |
| }); |
| TestStrictXUnionInStruct.clone( |
| TestStrictXUnionInStruct $orig, { |
| SampleStrictXUnion xu, |
| }) : this( |
| xu: xu ?? $orig.xu, |
| ); |
| |
| TestStrictXUnionInStruct._(List<Object> argv) : xu = argv[0]; |
| final SampleStrictXUnion xu; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| xu, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TestStrictXUnionInStruct' r'(xu: ' + xu.toString() + r')'; |
| } |
| |
| static TestStrictXUnionInStruct _ctor(List<Object> argv) => |
| TestStrictXUnionInStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TestStrictXUnionInStruct> |
| kTestStrictXUnionInStruct_Type = $fidl.StructType<TestStrictXUnionInStruct>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<SampleStrictXUnion>( |
| type: kSampleStrictXUnion_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: TestStrictXUnionInStruct._ctor, |
| ); |
| |
| class TestFlexibleXUnionInStruct extends $fidl.Struct { |
| const TestFlexibleXUnionInStruct({ |
| @required this.xu, |
| }); |
| TestFlexibleXUnionInStruct.clone( |
| TestFlexibleXUnionInStruct $orig, { |
| SampleXUnion xu, |
| }) : this( |
| xu: xu ?? $orig.xu, |
| ); |
| |
| TestFlexibleXUnionInStruct._(List<Object> argv) : xu = argv[0]; |
| final SampleXUnion xu; |
| |
| @override |
| List<Object> get $fields { |
| return <Object>[ |
| xu, |
| ]; |
| } |
| |
| @override |
| String toString() { |
| // ignore: prefer_interpolation_to_compose_strings |
| return r'TestFlexibleXUnionInStruct' r'(xu: ' + xu.toString() + r')'; |
| } |
| |
| static TestFlexibleXUnionInStruct _ctor(List<Object> argv) => |
| TestFlexibleXUnionInStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.StructType<TestFlexibleXUnionInStruct> |
| kTestFlexibleXUnionInStruct_Type = |
| $fidl.StructType<TestFlexibleXUnionInStruct>( |
| inlineSizeOld: 24, |
| inlineSizeV1: 24, |
| members: <$fidl.MemberType>[ |
| $fidl.MemberType<SampleXUnion>( |
| type: kSampleXUnion_Type, offsetOld: 0, offsetV1: 0), |
| ], |
| ctor: TestFlexibleXUnionInStruct._ctor, |
| ); |
| |
| class XUnionInTable extends $fidl.Table { |
| const XUnionInTable({ |
| this.before, |
| this.xu, |
| this.after, |
| }); |
| |
| XUnionInTable._(Map<int, dynamic> argv) |
| : before = argv[1], |
| xu = argv[2], |
| after = argv[3]; |
| final String before; |
| final SampleXUnion xu; |
| final String after; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: before, |
| 2: xu, |
| 3: after, |
| }; |
| } |
| |
| static XUnionInTable _ctor(Map<int, dynamic> argv) => XUnionInTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<XUnionInTable> kXUnionInTable_Type = |
| $fidl.TableType<XUnionInTable>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 2: kSampleXUnion_Type, |
| 3: $fidl.StringType(maybeElementCount: null, nullable: false), |
| }, |
| ctor: XUnionInTable._ctor, |
| ); |
| |
| class SimpleTable extends $fidl.Table { |
| const SimpleTable({ |
| this.x, |
| this.y, |
| }); |
| |
| SimpleTable._(Map<int, dynamic> argv) |
| : x = argv[1], |
| y = argv[5]; |
| final int x; |
| final int y; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: x, |
| 5: y, |
| }; |
| } |
| |
| static SimpleTable _ctor(Map<int, dynamic> argv) => SimpleTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<SimpleTable> kSimpleTable_Type = |
| $fidl.TableType<SimpleTable>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Int64Type(), |
| 5: $fidl.Int64Type(), |
| }, |
| ctor: SimpleTable._ctor, |
| ); |
| |
| class TableWithStringAndVector extends $fidl.Table { |
| const TableWithStringAndVector({ |
| this.foo, |
| this.bar, |
| this.baz, |
| }); |
| |
| TableWithStringAndVector._(Map<int, dynamic> argv) |
| : foo = argv[1], |
| bar = argv[2], |
| baz = argv[3]; |
| final String foo; |
| final int bar; |
| final Uint8List baz; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: foo, |
| 2: bar, |
| 3: baz, |
| }; |
| } |
| |
| static TableWithStringAndVector _ctor(Map<int, dynamic> argv) => |
| TableWithStringAndVector._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableWithStringAndVector> kTableWithStringAndVector_Type = |
| $fidl.TableType<TableWithStringAndVector>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: null, nullable: false), |
| 2: $fidl.Int32Type(), |
| 3: $fidl.VectorType<Uint8List>( |
| element: $fidl.Uint8Type(), maybeElementCount: null, nullable: false), |
| }, |
| ctor: TableWithStringAndVector._ctor, |
| ); |
| |
| class ReverseOrdinalTable extends $fidl.Table { |
| const ReverseOrdinalTable({ |
| this.z, |
| this.y, |
| this.x, |
| }); |
| |
| ReverseOrdinalTable._(Map<int, dynamic> argv) |
| : z = argv[1], |
| y = argv[2], |
| x = argv[4]; |
| final int z; |
| final int y; |
| final int x; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: z, |
| 2: y, |
| 4: x, |
| }; |
| } |
| |
| static ReverseOrdinalTable _ctor(Map<int, dynamic> argv) => |
| ReverseOrdinalTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<ReverseOrdinalTable> kReverseOrdinalTable_Type = |
| $fidl.TableType<ReverseOrdinalTable>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Int64Type(), |
| 2: $fidl.Int64Type(), |
| 4: $fidl.Int64Type(), |
| }, |
| ctor: ReverseOrdinalTable._ctor, |
| ); |
| |
| class TableWithEmptyStruct extends $fidl.Table { |
| const TableWithEmptyStruct({ |
| this.s, |
| }); |
| |
| TableWithEmptyStruct._(Map<int, dynamic> argv) : s = argv[1]; |
| final EmptyStruct s; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: s, |
| }; |
| } |
| |
| static TableWithEmptyStruct _ctor(Map<int, dynamic> argv) => |
| TableWithEmptyStruct._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableWithEmptyStruct> kTableWithEmptyStruct_Type = |
| $fidl.TableType<TableWithEmptyStruct>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: kEmptyStruct_Type, |
| }, |
| ctor: TableWithEmptyStruct._ctor, |
| ); |
| |
| class TableNoFields extends $fidl.Table { |
| const TableNoFields(); |
| |
| TableNoFields._(Map<int, dynamic> argv); |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return {}; |
| } |
| |
| static TableNoFields _ctor(Map<int, dynamic> argv) => TableNoFields._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableNoFields> kTable_NoFields_Type = |
| $fidl.TableType<TableNoFields>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{}, |
| ctor: TableNoFields._ctor, |
| ); |
| |
| class TableTwoReservedFields extends $fidl.Table { |
| const TableTwoReservedFields(); |
| |
| TableTwoReservedFields._(Map<int, dynamic> argv); |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return {}; |
| } |
| |
| static TableTwoReservedFields _ctor(Map<int, dynamic> argv) => |
| TableTwoReservedFields._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableTwoReservedFields> kTable_TwoReservedFields_Type = |
| $fidl.TableType<TableTwoReservedFields>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{}, |
| ctor: TableTwoReservedFields._ctor, |
| ); |
| |
| class TableStructWithReservedSandwich extends $fidl.Table { |
| const TableStructWithReservedSandwich({ |
| this.s1, |
| this.s2, |
| }); |
| |
| TableStructWithReservedSandwich._(Map<int, dynamic> argv) |
| : s1 = argv[2], |
| s2 = argv[3]; |
| final StructSize3Align1 s1; |
| final StructSize3Align1 s2; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 2: s1, |
| 3: s2, |
| }; |
| } |
| |
| static TableStructWithReservedSandwich _ctor(Map<int, dynamic> argv) => |
| TableStructWithReservedSandwich._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableStructWithReservedSandwich> |
| kTable_StructWithReservedSandwich_Type = |
| $fidl.TableType<TableStructWithReservedSandwich>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 2: kStructSize3Align1_Type, |
| 3: kStructSize3Align1_Type, |
| }, |
| ctor: TableStructWithReservedSandwich._ctor, |
| ); |
| |
| class TableStructWithUint32Sandwich extends $fidl.Table { |
| const TableStructWithUint32Sandwich({ |
| this.i, |
| this.s1, |
| this.s2, |
| this.i2, |
| }); |
| |
| TableStructWithUint32Sandwich._(Map<int, dynamic> argv) |
| : i = argv[1], |
| s1 = argv[2], |
| s2 = argv[3], |
| i2 = argv[4]; |
| final int i; |
| final StructSize3Align1 s1; |
| final StructSize3Align1 s2; |
| final int i2; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: i, |
| 2: s1, |
| 3: s2, |
| 4: i2, |
| }; |
| } |
| |
| static TableStructWithUint32Sandwich _ctor(Map<int, dynamic> argv) => |
| TableStructWithUint32Sandwich._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableStructWithUint32Sandwich> |
| kTable_StructWithUint32Sandwich_Type = |
| $fidl.TableType<TableStructWithUint32Sandwich>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint32Type(), |
| 2: kStructSize3Align1_Type, |
| 3: kStructSize3Align1_Type, |
| 4: $fidl.Uint32Type(), |
| }, |
| ctor: TableStructWithUint32Sandwich._ctor, |
| ); |
| |
| class TableUnionWithVectorReservedSandwich extends $fidl.Table { |
| const TableUnionWithVectorReservedSandwich({ |
| this.uv, |
| }); |
| |
| TableUnionWithVectorReservedSandwich._(Map<int, dynamic> argv) : uv = argv[2]; |
| final UnionWithVector uv; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 2: uv, |
| }; |
| } |
| |
| static TableUnionWithVectorReservedSandwich _ctor(Map<int, dynamic> argv) => |
| TableUnionWithVectorReservedSandwich._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableUnionWithVectorReservedSandwich> |
| kTable_UnionWithVector_ReservedSandwich_Type = |
| $fidl.TableType<TableUnionWithVectorReservedSandwich>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 2: kUnionWithVector_Type, |
| }, |
| ctor: TableUnionWithVectorReservedSandwich._ctor, |
| ); |
| |
| class TableUnionWithVectorStructSandwich extends $fidl.Table { |
| const TableUnionWithVectorStructSandwich({ |
| this.s1, |
| this.uv, |
| this.s2, |
| }); |
| |
| TableUnionWithVectorStructSandwich._(Map<int, dynamic> argv) |
| : s1 = argv[1], |
| uv = argv[2], |
| s2 = argv[3]; |
| final StructSize3Align1 s1; |
| final UnionWithVector uv; |
| final StructSize3Align1 s2; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: s1, |
| 2: uv, |
| 3: s2, |
| }; |
| } |
| |
| static TableUnionWithVectorStructSandwich _ctor(Map<int, dynamic> argv) => |
| TableUnionWithVectorStructSandwich._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableUnionWithVectorStructSandwich> |
| kTable_UnionWithVector_StructSandwich_Type = |
| $fidl.TableType<TableUnionWithVectorStructSandwich>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: kStructSize3Align1_Type, |
| 2: kUnionWithVector_Type, |
| 3: kStructSize3Align1_Type, |
| }, |
| ctor: TableUnionWithVectorStructSandwich._ctor, |
| ); |
| |
| class TableOfXUnionThenUnion extends $fidl.Table { |
| const TableOfXUnionThenUnion({ |
| this.member, |
| }); |
| |
| TableOfXUnionThenUnion._(Map<int, dynamic> argv) : member = argv[2]; |
| final XUnionOfUnion member; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 2: member, |
| }; |
| } |
| |
| static TableOfXUnionThenUnion _ctor(Map<int, dynamic> argv) => |
| TableOfXUnionThenUnion._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableOfXUnionThenUnion> kTableOfXUnionThenUnion_Type = |
| $fidl.TableType<TableOfXUnionThenUnion>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 2: kXUnionOfUnion_Type, |
| }, |
| ctor: TableOfXUnionThenUnion._ctor, |
| ); |
| |
| class TableOfUnionThenXUnionThenTableThenXUnionThenUnion extends $fidl.Table { |
| const TableOfUnionThenXUnionThenTableThenXUnionThenUnion({ |
| this.member, |
| }); |
| |
| TableOfUnionThenXUnionThenTableThenXUnionThenUnion._(Map<int, dynamic> argv) |
| : member = argv[3]; |
| final UnionOfXUnionThenTableThenXUnionThenUnion member; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 3: member, |
| }; |
| } |
| |
| static TableOfUnionThenXUnionThenTableThenXUnionThenUnion _ctor( |
| Map<int, dynamic> argv) => |
| TableOfUnionThenXUnionThenTableThenXUnionThenUnion._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableOfUnionThenXUnionThenTableThenXUnionThenUnion> |
| kTableOfUnionThenXUnionThenTableThenXUnionThenUnion_Type = |
| $fidl.TableType<TableOfUnionThenXUnionThenTableThenXUnionThenUnion>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 3: kUnionOfXUnionThenTableThenXUnionThenUnion_Type, |
| }, |
| ctor: TableOfUnionThenXUnionThenTableThenXUnionThenUnion._ctor, |
| ); |
| |
| class TableWithUnionSize12Align4 extends $fidl.Table { |
| const TableWithUnionSize12Align4({ |
| this.before, |
| this.member, |
| this.after, |
| }); |
| |
| TableWithUnionSize12Align4._(Map<int, dynamic> argv) |
| : before = argv[1], |
| member = argv[3], |
| after = argv[5]; |
| final int before; |
| final UnionSize12Align4 member; |
| final int after; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: before, |
| 3: member, |
| 5: after, |
| }; |
| } |
| |
| static TableWithUnionSize12Align4 _ctor(Map<int, dynamic> argv) => |
| TableWithUnionSize12Align4._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableWithUnionSize12Align4> |
| kTableWithUnionSize12Align4_Type = |
| $fidl.TableType<TableWithUnionSize12Align4>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint8Type(), |
| 3: kUnionSize12Align4_Type, |
| 5: $fidl.Uint8Type(), |
| }, |
| ctor: TableWithUnionSize12Align4._ctor, |
| ); |
| |
| class Regression10TableV1 extends $fidl.Table { |
| const Regression10TableV1({ |
| this.member1, |
| }); |
| |
| Regression10TableV1._(Map<int, dynamic> argv) : member1 = argv[1]; |
| final int member1; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: member1, |
| }; |
| } |
| |
| static Regression10TableV1 _ctor(Map<int, dynamic> argv) => |
| Regression10TableV1._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<Regression10TableV1> kRegression10TableV1_Type = |
| $fidl.TableType<Regression10TableV1>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint64Type(), |
| }, |
| ctor: Regression10TableV1._ctor, |
| ); |
| |
| class Regression10TableV2 extends $fidl.Table { |
| const Regression10TableV2({ |
| this.member1, |
| this.member2, |
| }); |
| |
| Regression10TableV2._(Map<int, dynamic> argv) |
| : member1 = argv[1], |
| member2 = argv[5]; |
| final int member1; |
| final int member2; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: member1, |
| 5: member2, |
| }; |
| } |
| |
| static Regression10TableV2 _ctor(Map<int, dynamic> argv) => |
| Regression10TableV2._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<Regression10TableV2> kRegression10TableV2_Type = |
| $fidl.TableType<Regression10TableV2>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint64Type(), |
| 5: $fidl.Uint64Type(), |
| }, |
| ctor: Regression10TableV2._ctor, |
| ); |
| |
| class Regression10TableV3 extends $fidl.Table { |
| const Regression10TableV3({ |
| this.x, |
| this.y, |
| this.z, |
| }); |
| |
| Regression10TableV3._(Map<int, dynamic> argv) |
| : x = argv[1], |
| y = argv[5], |
| z = argv[6]; |
| final int x; |
| final int y; |
| final int z; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: x, |
| 5: y, |
| 6: z, |
| }; |
| } |
| |
| static Regression10TableV3 _ctor(Map<int, dynamic> argv) => |
| Regression10TableV3._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<Regression10TableV3> kRegression10TableV3_Type = |
| $fidl.TableType<Regression10TableV3>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Int64Type(), |
| 5: $fidl.Int64Type(), |
| 6: $fidl.Int64Type(), |
| }, |
| ctor: Regression10TableV3._ctor, |
| ); |
| |
| class TransformerSimpleTable extends $fidl.Table { |
| const TransformerSimpleTable({ |
| this.value, |
| }); |
| |
| TransformerSimpleTable._(Map<int, dynamic> argv) : value = argv[1]; |
| final int value; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: value, |
| }; |
| } |
| |
| static TransformerSimpleTable _ctor(Map<int, dynamic> argv) => |
| TransformerSimpleTable._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TransformerSimpleTable> kTransformerSimpleTable_Type = |
| $fidl.TableType<TransformerSimpleTable>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.Uint32Type(), |
| }, |
| ctor: TransformerSimpleTable._ctor, |
| ); |
| |
| class CompatTableString extends $fidl.Table { |
| const CompatTableString({ |
| this.s, |
| }); |
| |
| CompatTableString._(Map<int, dynamic> argv) : s = argv[1]; |
| final String s; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: s, |
| }; |
| } |
| |
| static CompatTableString _ctor(Map<int, dynamic> argv) => |
| CompatTableString._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<CompatTableString> kCompatTableString_Type = |
| $fidl.TableType<CompatTableString>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: $fidl.StringType(maybeElementCount: null, nullable: false), |
| }, |
| ctor: CompatTableString._ctor, |
| ); |
| |
| class CompatTableValue extends $fidl.Table { |
| const CompatTableValue({ |
| this.unionMember, |
| this.arrayMember, |
| this.tableMember, |
| this.xunionMember, |
| }); |
| |
| CompatTableValue._(Map<int, dynamic> argv) |
| : unionMember = argv[1], |
| arrayMember = argv[2], |
| tableMember = argv[3], |
| xunionMember = argv[4]; |
| final CompatUnion unionMember; |
| final Uint32List arrayMember; |
| final CompatTableString tableMember; |
| final CompatXUnion xunionMember; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: unionMember, |
| 2: arrayMember, |
| 3: tableMember, |
| 4: xunionMember, |
| }; |
| } |
| |
| static CompatTableValue _ctor(Map<int, dynamic> argv) => |
| CompatTableValue._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<CompatTableValue> kCompatTableValue_Type = |
| $fidl.TableType<CompatTableValue>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: kCompatUnion_Type, |
| 2: $fidl.ArrayType<Uint32List>( |
| element: $fidl.Uint32Type(), elementCount: 3), |
| 3: kCompatTableString_Type, |
| 4: kCompatXUnion_Type, |
| }, |
| ctor: CompatTableValue._ctor, |
| ); |
| |
| class TableWithXUnion extends $fidl.Table { |
| const TableWithXUnion({ |
| this.member, |
| }); |
| |
| TableWithXUnion._(Map<int, dynamic> argv) : member = argv[1]; |
| final CompatXUnion member; |
| |
| @override |
| Map<int, dynamic> get $fields { |
| return { |
| 1: member, |
| }; |
| } |
| |
| static TableWithXUnion _ctor(Map<int, dynamic> argv) => |
| TableWithXUnion._(argv); |
| } |
| |
| // See FIDL-308: |
| // ignore: recursive_compile_time_constant |
| const $fidl.TableType<TableWithXUnion> kTableWithXUnion_Type = |
| $fidl.TableType<TableWithXUnion>( |
| inlineSizeOld: 16, |
| inlineSizeV1: 16, |
| members: <int, $fidl.FidlType>{ |
| 1: kCompatXUnion_Type, |
| }, |
| ctor: TableWithXUnion._ctor, |
| ); |
| |
| // ignore: unused_element, avoid_private_typedef_functions |
| typedef _VoidCallback = void Function(); |
| |
| abstract class EthernetDevice extends $fidl.Service { |
| static const String $serviceName = null; |
| @override |
| $fidl.ServiceData get $serviceData => EthernetDeviceData(); |
| } |
| |
| class EthernetDeviceData implements $fidl.ServiceData<EthernetDevice> { |
| const EthernetDeviceData(); |
| |
| @override |
| String getName() { |
| return EthernetDevice.$serviceName; |
| } |
| |
| @override |
| $fidl.AsyncBinding getBinding() { |
| return EthernetDeviceBinding(); |
| } |
| } |
| |
| class EthernetDeviceProxy extends $fidl.AsyncProxy<EthernetDevice> |
| implements EthernetDevice { |
| EthernetDeviceProxy() |
| : super($fidl.AsyncProxyController<EthernetDevice>( |
| $serviceName: null, $interfaceName: r'EthernetDevice')) { |
| ctrl.onResponse = _handleResponse; |
| } |
| |
| @override |
| $fidl.ServiceData get $serviceData => EthernetDeviceData(); |
| |
| void _handleEvent($fidl.Message $message) { |
| final $fidl.Decoder $decoder = $fidl.Decoder($message); |
| switch ($message.ordinal) { |
| default: |
| ctrl.proxyError( |
| $fidl.FidlError('Unexpected message ordinal: ${$message.ordinal}')); |
| ctrl.close(); |
| break; |
| } |
| } |
| |
| void _handleResponse($fidl.Message $message) { |
| final int $txid = $message.txid; |
| if ($txid == 0) { |
| _handleEvent($message); |
| return; |
| } |
| final $async.Completer $completer = ctrl.getCompleter($txid); |
| if ($completer == null) { |
| $message.closeHandles(); |
| return; |
| } |
| final $fidl.Decoder $decoder = $fidl.Decoder($message); |
| switch ($message.ordinal) { |
| default: |
| ctrl.proxyError( |
| $fidl.FidlError('Unexpected message ordinal: ${$message.ordinal}')); |
| ctrl.close(); |
| break; |
| } |
| } |
| } |
| |
| class EthernetDeviceBinding extends $fidl.AsyncBinding<EthernetDevice> { |
| EthernetDeviceBinding() : super(r"EthernetDevice"); |
| |
| @override |
| void handleMessage($fidl.Message $message, $fidl.MessageSink $respond) { |
| final $fidl.Decoder $decoder = $fidl.Decoder($message); |
| switch ($message.ordinal) { |
| default: |
| throw $fidl.FidlError( |
| r'Unexpected message name for EthernetDeviceBinding'); |
| } |
| } |
| } |