register<T extends Object> method

Resolvable<T> register<T extends Object>(FutureOr<T> value, { TOnRegisterCallback<T>? onRegister, TOnUnregisterCallback<T>? onUnregister, Entity groupEntity = const DefaultEntity(), bool enableUntilExactlyK = false, })

Registers a dependency with the container.

Implementation

Resolvable<T> register<T extends Object>(
  FutureOr<T> value, {
  TOnRegisterCallback<T>? onRegister,
  TOnUnregisterCallback<T>? onUnregister,
  Entity groupEntity = const DefaultEntity(),
  bool enableUntilExactlyK = false,
}) {
  assert(T != Object, 'T must be specified and cannot be Object.');
  final g = groupEntity.preferOverDefault(focusGroup);
  final metadata = DependencyMetadata(
    index: Some(_indexIncrementer++),
    groupEntity: g,
    onUnregister: onUnregister != null
        ? Some((e) => onUnregister(e.transf()))
        : const None(),
  );
  final a = Resolvable(
    () => consec(value, (e) => consec(onRegister?.call(e), (_) => e)),
  );
  final b = registerDependency<T>(
    dependency: Dependency(a, metadata: Some(metadata)),
    checkExisting: true,
  );
  UNSAFE:
  {
    if (b.isErr()) {
      return Sync.err(b.err().unwrap().transfErr<T>());
    }
    if (value is! ReservedSafeCompleter<T>) {
      // Used for until.
      // NOTE: CHANGED FROM T TO Object so that it attems to finish ANY ReservedSafeFinisher!
      _maybeFinish<Object>(value: value, g: g);

      // Used for untilT and untilK. Disabled by default to improve performance.
      if (enableUntilExactlyK) {
        (this as SupportsMixinK).maybeFinishK<T>(g: g);
      }
    }
    return get<T>(groupEntity: groupEntity).unwrap();
  }
}