sortedByInputDependency method

List<Node<T>> sortedByInputDependency({ int? maxDepth, bool bfs = false, })

Implementation

List<Node<T>> sortedByInputDependency({int? maxDepth, bool bfs = false}) {
  var nodesInputs = inputsInDepth(bfs: bfs);

  var nodesInputsEntries = nodesInputs.entries.toList();

  var directRoots =
      nodesInputsEntries.where((e) => e.value.isEmpty).keys.toList();

  directRoots = directRoots.sortedByOutputDependency(maxDepth: maxDepth);

  if (directRoots.length == nodesInputsEntries.length) {
    return directRoots;
  }

  nodesInputsEntries.removeWhere((e) => directRoots.contains(e.key));

  var entriesIntersections = nodesInputsEntries.map((e) {
    var entryInputs = e.value;
    var otherEntries = nodesInputsEntries.where((e2) => e2 != e);

    var intersections = otherEntries
        .map((other) =>
            MapEntry(other.key, entryInputs.intersection(other.value)))
        .where((other) => other.value.isNotEmpty);

    return MapEntry(e.key, Map.fromEntries(intersections));
  }).toList();

  var isolated =
      entriesIntersections.where((e) => e.value.isEmpty).keys.toList();

  nodesInputsEntries.removeWhere((e) => isolated.contains(e.key));

  isolated = isolated.sortedByOutputsDepth().toReversedList(growable: false);

  var rest = nodesInputsEntries.keys.sortedByOutputsDepth().toReversedList();

  var nodes = [...directRoots, ...isolated, ...rest].toList();
  return nodes;
}