// WARNING: This file is machine generated by fidlgen_dart.
// @dart = 2.8

library fidl_fidl_test_requestflexibleenvelope_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 $zircon;

// 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
// ignore_for_file: prefer_interpolation_to_compose_strings

enum FlexibleFooTag {
  $unknown,
  s, // 0x1
  i, // 0x2
}

const Map<int, FlexibleFooTag> _FlexibleFooTag_map = {
  1: FlexibleFooTag.s,
  2: FlexibleFooTag.i,
};

class FlexibleFoo extends $fidl.XUnion {
  const FlexibleFoo.withS(String value)
      : _ordinal = 1,
        _data = value;

  const FlexibleFoo.withI(int value)
      : _ordinal = 2,
        _data = value;
  const FlexibleFoo.with$UnknownData(this._ordinal, $fidl.UnknownRawData data)
      : _data = data;

  FlexibleFoo._(int ordinal, Object data)
      : _ordinal = ordinal,
        _data = data;

  final int _ordinal;
  final _data;

  FlexibleFooTag get $tag {
    final FlexibleFooTag $rawtag = _FlexibleFooTag_map[_ordinal];
    return $rawtag == null ? FlexibleFooTag.$unknown : $rawtag;
  }

  String get s {
    if (_ordinal != 1) {
      return null;
    }
    return _data;
  }

  int get i {
    if (_ordinal != 2) {
      return null;
    }
    return _data;
  }

  @override
  String toString() {
    switch (_ordinal) {
      case 1:
        return r'FlexibleFoo.s(' + s.toString() + ')';
      case 2:
        return r'FlexibleFoo.i(' + i.toString() + ')';
      default:
        return r'FlexibleFoo.<UNKNOWN>';
    }
  }

  @override
  int get $ordinal => _ordinal;

  @override
  Object get $data => _data;

  static FlexibleFoo _ctor(int ordinal, Object data) {
    return FlexibleFoo._(ordinal, data);
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.XUnionType<FlexibleFoo> kFlexibleFoo_Type =
    $fidl.XUnionType<FlexibleFoo>(
  members: <int, $fidl.FidlType>{
    1: $fidl.StringType(maybeElementCount: null, nullable: false),
    2: $fidl.Int32Type(),
  },
  ctor: FlexibleFoo._ctor,
  nullable: false,
  flexible: true,
);
// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.XUnionType<FlexibleFoo> kFlexibleFoo_OptType =
    $fidl.XUnionType<FlexibleFoo>(
  members: <int, $fidl.FidlType>{
    1: $fidl.StringType(maybeElementCount: null, nullable: false),
    2: $fidl.Int32Type(),
  },
  ctor: FlexibleFoo._ctor,
  nullable: true,
  flexible: true,
);

enum StrictFooTag {
  s, // 0x1
  i, // 0x2
}

const Map<int, StrictFooTag> _StrictFooTag_map = {
  1: StrictFooTag.s,
  2: StrictFooTag.i,
};

class StrictFoo extends $fidl.XUnion {
  const StrictFoo.withS(String value)
      : _ordinal = 1,
        _data = value;

  const StrictFoo.withI(int value)
      : _ordinal = 2,
        _data = value;

  StrictFoo._(int ordinal, Object data)
      : _ordinal = ordinal,
        _data = data;

  final int _ordinal;
  final _data;

  StrictFooTag get $tag => _StrictFooTag_map[_ordinal];

  String get s {
    if (_ordinal != 1) {
      return null;
    }
    return _data;
  }

  int get i {
    if (_ordinal != 2) {
      return null;
    }
    return _data;
  }

  @override
  String toString() {
    switch (_ordinal) {
      case 1:
        return r'StrictFoo.s(' + s.toString() + ')';
      case 2:
        return r'StrictFoo.i(' + i.toString() + ')';
      default:
        return null;
    }
  }

  @override
  int get $ordinal => _ordinal;

  @override
  Object get $data => _data;

  static StrictFoo _ctor(int ordinal, Object data) {
    return StrictFoo._(ordinal, data);
  }
}

// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.XUnionType<StrictFoo> kStrictFoo_Type = $fidl.XUnionType<StrictFoo>(
  members: <int, $fidl.FidlType>{
    1: $fidl.StringType(maybeElementCount: null, nullable: false),
    2: $fidl.Int32Type(),
  },
  ctor: StrictFoo._ctor,
  nullable: false,
  flexible: false,
);
// See fxbug.dev/7644:
// ignore: recursive_compile_time_constant
const $fidl.XUnionType<StrictFoo> kStrictFoo_OptType =
    $fidl.XUnionType<StrictFoo>(
  members: <int, $fidl.FidlType>{
    1: $fidl.StringType(maybeElementCount: null, nullable: false),
    2: $fidl.Int32Type(),
  },
  ctor: StrictFoo._ctor,
  nullable: true,
  flexible: false,
);

// ignore: unused_element, avoid_private_typedef_functions
typedef _VoidCallback = void Function();

// requestStrictResponseFlexible: (StrictFoo s) -> (FlexibleFoo f)
const int _kProtocol_RequestStrictResponseFlexible_Ordinal = 0x3c5330c58686011a;
const $fidl.MethodType _kProtocol_RequestStrictResponseFlexible_Type =
    $fidl.MethodType(
  request: <$fidl.MemberType>[
    $fidl.MemberType<StrictFoo>(type: kStrictFoo_Type, offset: 0),
  ],
  response: <$fidl.MemberType>[
    $fidl.MemberType<FlexibleFoo>(type: kFlexibleFoo_Type, offset: 0),
  ],
  name: r"Protocol.RequestStrictResponseFlexible",
  requestInlineSize: 24,
  responseInlineSize: 24,
);
// requestFlexibleResponseStrict: (FlexibleFoo s) -> (StrictFoo f)
const int _kProtocol_RequestFlexibleResponseStrict_Ordinal = 0x3cb49d8f6e204f76;
const $fidl.MethodType _kProtocol_RequestFlexibleResponseStrict_Type =
    $fidl.MethodType(
  request: <$fidl.MemberType>[
    $fidl.MemberType<FlexibleFoo>(type: kFlexibleFoo_Type, offset: 0),
  ],
  response: <$fidl.MemberType>[
    $fidl.MemberType<StrictFoo>(type: kStrictFoo_Type, offset: 0),
  ],
  name: r"Protocol.RequestFlexibleResponseStrict",
  requestInlineSize: 24,
  responseInlineSize: 24,
);

abstract class Protocol extends $fidl.Service {
  static const String $serviceName = null;
  @override
  $fidl.ServiceData get $serviceData => ProtocolData();
  $async.Future<FlexibleFoo> requestStrictResponseFlexible(StrictFoo s);
  $async.Future<StrictFoo> requestFlexibleResponseStrict(FlexibleFoo s);
}

class ProtocolData implements $fidl.ServiceData<Protocol> {
  const ProtocolData();

  @override
  String getName() {
    return Protocol.$serviceName;
  }

  @override
  $fidl.AsyncBinding getBinding() {
    return ProtocolBinding();
  }
}

class ProtocolProxy extends $fidl.AsyncProxy<Protocol> implements Protocol {
  ProtocolProxy()
      : super($fidl.AsyncProxyController<Protocol>(
            $serviceName: null, $interfaceName: r'Protocol')) {
    ctrl.onResponse = _handleResponse;
  }

  @override
  $fidl.ServiceData get $serviceData => ProtocolData();

  void _handleEvent($fidl.Message $message) {
    final $fidl.Decoder $decoder = $fidl.Decoder($message)
      ..claimMemory($fidl.kMessageHeaderSize);
    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)
      ..claimMemory($fidl.kMessageHeaderSize);
    switch ($message.ordinal) {
      case _kProtocol_RequestStrictResponseFlexible_Ordinal:
        final String _name = _kProtocol_RequestStrictResponseFlexible_Type.name;
        try {
          Timeline.startSync(_name);
          final List<$fidl.MemberType> $types =
              _kProtocol_RequestStrictResponseFlexible_Type.response;
          $decoder.claimMemory(_kProtocol_RequestStrictResponseFlexible_Type
              .decodeResponseInlineSize($decoder));
          // ignore: prefer_const_declarations
          final $response =
              $types[0].decode($decoder, $fidl.kMessageHeaderSize);

          $completer.complete($response);
        } catch (_e) {
          ctrl.proxyError($fidl.FidlError(
              'Exception handling method response $_name: $_e'));
          ctrl.close();
          rethrow;
        } finally {
          Timeline.finishSync();
        }
        break;
      case _kProtocol_RequestFlexibleResponseStrict_Ordinal:
        final String _name = _kProtocol_RequestFlexibleResponseStrict_Type.name;
        try {
          Timeline.startSync(_name);
          final List<$fidl.MemberType> $types =
              _kProtocol_RequestFlexibleResponseStrict_Type.response;
          $decoder.claimMemory(_kProtocol_RequestFlexibleResponseStrict_Type
              .decodeResponseInlineSize($decoder));
          // ignore: prefer_const_declarations
          final $response =
              $types[0].decode($decoder, $fidl.kMessageHeaderSize);

          $completer.complete($response);
        } catch (_e) {
          ctrl.proxyError($fidl.FidlError(
              'Exception handling method response $_name: $_e'));
          ctrl.close();
          rethrow;
        } finally {
          Timeline.finishSync();
        }
        break;
      default:
        ctrl.proxyError(
            $fidl.FidlError('Unexpected message ordinal: ${$message.ordinal}'));
        ctrl.close();
        break;
    }
  }

  @override
  $async.Future<FlexibleFoo> requestStrictResponseFlexible(StrictFoo s) async {
    if (!ctrl.isBound) {
      return $async.Future.error(
          $fidl.FidlStateException('Proxy<${ctrl.$interfaceName}> is closed.'),
          StackTrace.current);
    }

    final $fidl.Encoder $encoder = $fidl.Encoder();
    $encoder.encodeMessageHeader(
        _kProtocol_RequestStrictResponseFlexible_Ordinal, 0);
    $encoder.alloc(_kProtocol_RequestStrictResponseFlexible_Type
        .encodingRequestInlineSize($encoder));
    final List<$fidl.MemberType> $types =
        _kProtocol_RequestStrictResponseFlexible_Type.request;
    $types[0].encode($encoder, s, $fidl.kMessageHeaderSize);
    final $completer = $async.Completer<FlexibleFoo>();
    ctrl.sendMessageWithResponse($encoder.message, $completer);
    return $completer.future;
  }

  @override
  $async.Future<StrictFoo> requestFlexibleResponseStrict(FlexibleFoo s) async {
    if (!ctrl.isBound) {
      return $async.Future.error(
          $fidl.FidlStateException('Proxy<${ctrl.$interfaceName}> is closed.'),
          StackTrace.current);
    }

    final $fidl.Encoder $encoder = $fidl.Encoder();
    $encoder.encodeMessageHeader(
        _kProtocol_RequestFlexibleResponseStrict_Ordinal, 0);
    $encoder.alloc(_kProtocol_RequestFlexibleResponseStrict_Type
        .encodingRequestInlineSize($encoder));
    final List<$fidl.MemberType> $types =
        _kProtocol_RequestFlexibleResponseStrict_Type.request;
    $types[0].encode($encoder, s, $fidl.kMessageHeaderSize);
    final $completer = $async.Completer<StrictFoo>();
    ctrl.sendMessageWithResponse($encoder.message, $completer);
    return $completer.future;
  }
}

class ProtocolBinding extends $fidl.AsyncBinding<Protocol> {
  ProtocolBinding() : super(r"Protocol");

  @override
  void handleMessage($fidl.Message $message, $fidl.MessageSink $respond) {
    final $fidl.Decoder $decoder = $fidl.Decoder($message)
      ..claimMemory($fidl.kMessageHeaderSize);
    switch ($message.ordinal) {
      case _kProtocol_RequestStrictResponseFlexible_Ordinal:
        final String _name = _kProtocol_RequestStrictResponseFlexible_Type.name;
        try {
          Timeline.startSync(_name);
          final List<$fidl.MemberType> $types =
              _kProtocol_RequestStrictResponseFlexible_Type.request;
          $decoder.claimMemory(_kProtocol_RequestStrictResponseFlexible_Type
              .decodeRequestInlineSize($decoder));
          final $async.Future<FlexibleFoo> $future =
              impl.requestStrictResponseFlexible(
            $types[0].decode($decoder, $fidl.kMessageHeaderSize),
          );
          $future.then(($response) {
            final $fidl.Encoder $encoder = $fidl.Encoder();
            $encoder.encodeMessageHeader(
                _kProtocol_RequestStrictResponseFlexible_Ordinal,
                $message.txid);
            $encoder.alloc(_kProtocol_RequestStrictResponseFlexible_Type
                .encodingResponseInlineSize($encoder));
            final List<$fidl.MemberType> $types =
                _kProtocol_RequestStrictResponseFlexible_Type.response;
            $types[0].encode($encoder, $response, $fidl.kMessageHeaderSize);
            $respond($encoder.message);
          }, onError: (_e) {
            close();
            print('Exception handling method call $_name: $_e');
          });
        } catch (_e) {
          close();
          print('Exception handling method call $_name: $_e');
          rethrow;
        } finally {
          Timeline.finishSync();
        }
        break;
      case _kProtocol_RequestFlexibleResponseStrict_Ordinal:
        final String _name = _kProtocol_RequestFlexibleResponseStrict_Type.name;
        try {
          Timeline.startSync(_name);
          final List<$fidl.MemberType> $types =
              _kProtocol_RequestFlexibleResponseStrict_Type.request;
          $decoder.claimMemory(_kProtocol_RequestFlexibleResponseStrict_Type
              .decodeRequestInlineSize($decoder));
          final $async.Future<StrictFoo> $future =
              impl.requestFlexibleResponseStrict(
            $types[0].decode($decoder, $fidl.kMessageHeaderSize),
          );
          $future.then(($response) {
            final $fidl.Encoder $encoder = $fidl.Encoder();
            $encoder.encodeMessageHeader(
                _kProtocol_RequestFlexibleResponseStrict_Ordinal,
                $message.txid);
            $encoder.alloc(_kProtocol_RequestFlexibleResponseStrict_Type
                .encodingResponseInlineSize($encoder));
            final List<$fidl.MemberType> $types =
                _kProtocol_RequestFlexibleResponseStrict_Type.response;
            $types[0].encode($encoder, $response, $fidl.kMessageHeaderSize);
            $respond($encoder.message);
          }, onError: (_e) {
            close();
            print('Exception handling method call $_name: $_e');
          });
        } catch (_e) {
          close();
          print('Exception handling method call $_name: $_e');
          rethrow;
        } finally {
          Timeline.finishSync();
        }
        break;
      default:
        throw $fidl.FidlError(r'Unexpected message name for ProtocolBinding');
    }
  }
}