reportRead static method

void reportRead(ListenerRegistry registry, { String? label, })

Called from an observable's value getter to register the current tracking context's own TrackingContext.onDependencyChanged callback (if any context is active) as a listener of registry. The context, not the observable, owns the callback that must run when registry notifies — an observable must never register itself as its own listener.

Chamado a partir do getter value de um observável para registrar o callback TrackingContext.onDependencyChanged do contexto de rastreamento atual (se houver algum ativo) como listener de registry. É o contexto, não o observável, que possui o callback a ser executado quando registry notificar — um observável nunca deve se registrar como seu próprio listener.

Implementation

static void reportRead(ListenerRegistry registry, {String? label}) {
  if (_suspendDepth > 0) {
    return; // untracked(): no context AND no engine link / sem link no motor
  }
  // Engine path (engine v2): while a CoreComputed is recomputing, every
  // read links this registry's engine node as a dependency of it. The
  // node is created lazily, so registries never read inside a computed
  // pay nothing.
  //
  // Caminho do motor (motor v2): enquanto um CoreComputed recomputa, cada
  // leitura liga o nó de motor deste registry como dependência dele. O nó
  // é criado preguiçosamente, então registries nunca lidos dentro de um
  // computed não pagam nada.
  final ObserverEngine engine = ObserverEngine.instance;
  final ReactiveNode? engineSub = engine.activeSub;
  if (engineSub != null) {
    engine.link(
      registry.engineNode ??= RegistrySignalNode(),
      engineSub,
      engine.cycle,
    );
  }
  final TrackingContext? context = current;
  if (context == null) {
    return;
  }
  context.readCount++;
  if (context._hasSeen(registry)) {
    return;
  }
  if (context.subscribes) {
    final ObserverVoidCallback listener =
        context.onDependencyChangedFrom == null
        ? context.onDependencyChanged
        : () => context.onDependencyChangedFrom!(registry);
    final Disposer disposer = registry.add(listener);
    context.disposers.add(disposer);
  }
  if (label != null) {
    context.trackedLabels.add(label);
    if (context.ownerLabel != null) {
      dispatchToInspectors(
        ObserverConfig.inspectors,
        (ObserverInspector i) => i.onTrack(
          TrackEvent(
            context.ownerLabel!,
            label,
            stackTrace: ObserverConfig.captureStackTraces
                ? StackTrace.current
                : null,
          ),
        ),
      );
    }
  }
}