unregisterAll method

Resolvable<Unit> unregisterAll({ TOnUnregisterCallback<Dependency<Object>>? onBeforeUnregister, TOnUnregisterCallback<Dependency<Object>>? onAfterUnregister, bool condition(Dependency<Object>)?, })

Unregisters all dependencies, optionally with callbacks and conditions.

Implementation

Resolvable<Unit> unregisterAll({
  TOnUnregisterCallback<Dependency>? onBeforeUnregister,
  TOnUnregisterCallback<Dependency>? onAfterUnregister,
  bool Function(Dependency)? condition,
}) {
  final results = List.of(registry.reversedDependencies);
  final seq = TaskSequencer();
  for (final dependency in results) {
    if (onBeforeUnregister != null) {
      seq.then((_) {
        return Resolvable(
          () =>
              consec(onBeforeUnregister(Ok(dependency)), (_) => const None()),
        );
      }).end();
    }

    seq.then((_) {
      if (condition != null && !condition(dependency)) {
        return syncNone();
      }
      registry
          .removeDependencyK(
            dependency.typeEntity,
            groupEntity: dependency.metadata
                .map((e) => e.groupEntity)
                .unwrapOr(const DefaultEntity()),
          )
          .end();
      final metadataOption = dependency.metadata;
      UNSAFE:
      if (metadataOption.isSome()) {
        final metadata = metadataOption.unwrap();
        final onUnregisterOption = metadata.onUnregister;
        if (onUnregisterOption.isSome()) {
          final onUnregister = onUnregisterOption.unwrap();
          return dependency.value.map((e) {
            return Resolvable<Resolvable<Option>>(
              () => consec(onUnregister(Ok(e)), (e) => syncNone()),
            ).flatten();
          }).flatten();
        }
      }
      return syncNone();
    }).end();
    if (onAfterUnregister != null) {
      seq.then((_) {
        return Resolvable(
          () =>
              consec(onAfterUnregister(Ok(dependency)), (_) => const None()),
        );
      }).end();
    }
  }
  return seq.completion.toUnit();
}