resolveAll method

Resolvable<Unit> resolveAll({ Option<Entity> groupEntity = const Some(DefaultEntity()), })

Completes once all Async dependencies associated with groupEntity complete, or every group when groupEntity is None.

Implementation

Resolvable<Unit> resolveAll({
  Option<Entity> groupEntity = const Some(DefaultEntity()),
}) {
  UNSAFE:
  return Resolvable(() {
    // Snapshot the registry's unsorted dependencies up front so a
    // re-entrant register/unregister fired from `wait`'s callback (which
    // recursively calls `resolveAll`) cannot trigger
    // `ConcurrentModificationError` while we're still iterating.
    var resolvables = registry.unsortedDependencies
        .toList(growable: false)
        .cast<Dependency>();
    if (groupEntity case Some(value: final g)) {
      resolvables = resolvables
          .where(
            (e) => switch (e.metadata) {
              Some(value: final m) => m.groupEntity == g,
              None() => false,
            },
          )
          .toList(growable: false);
    }
    final values = resolvables.map((e) => e.value);
    if (values.any((e) => e is Async)) {
      return wait(
        resolvables.map((e) => e.value.unwrap()),
        (_) => resolveAll(groupEntity: groupEntity).toUnit().unwrap(),
      );
    }
    return Unit();
  });
}