readProviderElement<Created, Listened> method

ProviderElement<Created, Listened> readProviderElement<Created, Listened>(ProviderBase<Created, Listened> provider)

Reads the state of a provider, potentially creating it in the process.

It may throw if the provider requested threw when it was built.

Do not use this in production code. This is exposed only for testing and devtools, to be able to test if a provider has listeners or similar.

Implementation

ProviderElement<Created, Listened> readProviderElement<Created, Listened>(
  ProviderBase<Created, Listened> provider,
) {
  if (_disposed) {
    throw StateError(
      'Tried to read a provider from a ProviderContainer that was already disposed',
    );
  }
  if (_root != null && provider is RootProvider) {
    return _root!.readProviderElement(provider);
  }

  final element = _stateReaders.putIfAbsent(provider, () {
    if (provider == _circularDependencyLock) {
      throw CircularDependencyError._();
    }
    _circularDependencyLock ??= provider;
    try {
      var override = _overrideForProvider[provider];

      if (override == null &&
          provider.from != null &&
          _overrideForFamily[provider.from] != null) {
        final familyOverride = _overrideForFamily[provider.from]!;
        override = familyOverride._createOverride(provider._argument)
            as ProviderBase<Created, Listened>;
      }

      override ??= provider;
      final element = override.createElement()
        .._provider = override
        .._origin = provider
        .._container = this
        ..mount();

      for (final observer in _observers) {
        _runBinaryGuarded<ProviderBase, Object?>(
          observer.didAddProvider,
          provider,
          element.state._exposedValue,
        );
      }
      return element;
    } finally {
      if (_circularDependencyLock == provider) {
        _circularDependencyLock = null;
      }
    }
  }) as ProviderElement<Created, Listened>;

  return element..flush();
}