connectIO method

Implementation

@override
void connectIO(Module module, Interface<dynamic> srcInterface,
    {Iterable<PairDirection>? inputTags,
    Iterable<PairDirection>? outputTags,
    Iterable<PairDirection>? inOutTags,
    String Function(String original)? uniquify}) {
  final nonNullUniquify = uniquify ?? (original) => original;
  // ignore: deprecated_member_use_from_same_package
  final nonNullModify = modify ?? (original) => original;
  String newUniquify(String original) =>
      nonNullUniquify(nonNullModify(original));

  super.connectIO(module, srcInterface,
      inputTags: inputTags,
      outputTags: outputTags,
      inOutTags: inOutTags,
      uniquify: newUniquify);

  if (subInterfaces.isNotEmpty) {
    if (srcInterface is! PairInterface) {
      throw InterfaceTypeException(
          srcInterface,
          'an Interface with subInterfaces'
          ' can only connect to a PairInterface');
    }

    for (final subInterfaceEntry in _subInterfaces.entries) {
      final subInterface = subInterfaceEntry.value.interface;
      final subInterfaceName = subInterfaceEntry.key;

      final nonNullSubIntfUniquify =
          subInterfaceEntry.value.uniquify ?? (original) => original;

      String newSubIntfUniquify(String original) =>
          nonNullUniquify(nonNullSubIntfUniquify(nonNullModify(original)));

      if (!srcInterface._subInterfaces.containsKey(subInterfaceName)) {
        throw InterfaceTypeException(
            srcInterface, 'missing a sub-interface named $subInterfaceName');
      }

      // handle possible reversal as best as we can
      Iterable<PairDirection>? subIntfInputTags;
      Iterable<PairDirection>? subIntfOutputTags;
      final subIntfInOutTags = inOutTags;

      if (subInterfaceEntry.value.reverse) {
        // swap consumer tag
        if (inputTags?.contains(PairDirection.fromConsumer) ?? false) {
          subIntfOutputTags = [PairDirection.fromConsumer];
        }
        if (outputTags?.contains(PairDirection.fromConsumer) ?? false) {
          subIntfInputTags = [PairDirection.fromConsumer];
        }

        // swap provider tag
        if (outputTags?.contains(PairDirection.fromProvider) ?? false) {
          subIntfInputTags = [PairDirection.fromProvider];
        }
        if (inputTags?.contains(PairDirection.fromProvider) ?? false) {
          subIntfOutputTags = [PairDirection.fromProvider];
        }

        // keep sharedInputs, if it's there
        if (inputTags?.contains(PairDirection.sharedInputs) ?? false) {
          subIntfInputTags = [
            if (subIntfInputTags != null) ...subIntfInputTags,
            PairDirection.sharedInputs,
          ];
        }
      } else {
        subIntfInputTags = inputTags;
        subIntfOutputTags = outputTags;
      }

      subInterface.connectIO(
        module,
        srcInterface._subInterfaces[subInterfaceName]!.interface,
        inputTags: subIntfInputTags,
        outputTags: subIntfOutputTags,
        inOutTags: subIntfInOutTags,
        uniquify: newSubIntfUniquify,
      );
    }
  }
}