Keep track of registered providers.

{@inheritdoc}
550978
public function register(ServiceProviderInterface $provider, array $values = array())
     {
         $this->registeredProviders[get_class($provider)] = true;

         parent::register($provider, $values);
     }
363434
public function registerExtensionProviders(ExtensionContract $extension)
    {
        $filePath = $extension->getPath() . '/providers.php';

        if ($this->files->exists($filePath)) {
            $providers = (array) $this->files->getRequire($filePath);

            $this->provides($providers);
        }
    }
979881
protected function tryRegisterProviders($on)
    {
        if ($on === $this->registerProvidersOn && $this->registerProvidersMethod === self::METHOD_REGISTER) {
            // FIRST register all given providers
            foreach ($this->providers as $provider) {
                $this->app->register($provider);
            }

            foreach ($this->deferredProviders as $provider) {
                $this->app->registerDeferredProvider($provider);
            }
        } elseif ($this->registerProvidersMethod === self::METHOD_RESOLVE) {
            foreach ($this->providers as $provider) {
                $resolved = $this->app->resolveProviderClass($registered[] = $provider);
                if ($on === self::ON_REGISTER) {
                    $resolved->register();
                } elseif ($on === self::ON_BOOT) {
                    $this->app->call([$provider, 'boot']);
                }
            }
        }
    }
33282
private function registerProviders()
    {
        $this->providers = $this->defaultProviders;

        $providers = [];
        foreach($this->providers as $provider) {
            if ($provider === 'EasyWeChat\Foundation\ServiceProviders\OpenPlatformServiceProvider') {
                continue;
            }

            $providers[] = $provider;
        }

        $this->providers = $providers;

        if ($this['config']['auth_type'] === Config::AUTH_TYPE_COMPONENT) {
            $providers = [];
            foreach($this->providers as $provider) {
                if ($provider === 'EasyWeChat\Foundation\ServiceProviders\ServerServiceProvider'
                    || $provider === 'EasyWeChat\Foundation\ServiceProviders\OAuthServiceProvider') {
                    continue;
                }

                $providers[] = $provider;
            }

            $this->providers = $providers;

            array_push($this->providers, ServiceProviders\OAuthServiceProvider::class);
            array_push($this->providers, ServiceProviders\ServerServiceProvider::class);
        }

        foreach ($this->providers as $provider) {
            $this->register(new $provider());
        }
    }
506344
private function setProviders($providers) {
        foreach ($providers as $key => $value) {
            $this->provides[] = $value;
            $this->app->appProviders[] = [$key=>$value];
        }
    }
389939
@Override
	public void registerOsgiProviders (Collection<Object> providers) throws FhirConfigurationException {
		if (null == providers) {
			throw new NullPointerException("FHIR Provider list cannot be null");
		}
		try {
			super.registerProviders(providers);
			for (Object provider : providers) {
				log.trace("registered provider. class ["+provider.getClass().getName()+"]");
				this.serverProviders.add(provider);
			}
		} catch (Exception e) {
			log.error("Error registering FHIR Providers", e);
			throw new FhirConfigurationException("Error registering FHIR Providers", e);
		}
	}
555610
public function registerProvider(ProviderInterface $provider)
    {
        $this->providers[$provider->getName()] = $provider;
        $this->sortProviders();

        return $this;
    }
1091981
public function registerDeferredProvider($provider, $service = null)
    {
        // Once the provider that provides the deferred service has been registered we
        // will remove it from our local list of the deferred services with related
        // providers so that this container does not try to resolve it out again.
        if ($service) {
            unset($this->deferredServices[$service]);
        }
        $this->registerProvider($instance = new $provider($this));
    }
324761
protected function registerProviders()
    {
        // register rollbar service provider
        if (class_exists(HCRollbarServiceProvider::class))
            $this->app->register(HCRollbarServiceProvider::class);

        // register LogViewer service provider
        if (class_exists(LaravelLogViewerServiceProvider::class))
            $this->app->register(LaravelLogViewerServiceProvider::class);
    }
968559
public function registerProvider(ProviderInterface $provider)
    {
        if (null !== $provider) {
            $this->providers[$provider->getName()] = $provider;
        }

        return $this;
    }
907238
def register_provider(cls, provider):
        """"""
        def decorator(subclass):
            """Register as decorator function."""
            cls._providers[provider] = subclass
            subclass.name = provider
            return subclass
        return decorator
1300536
public function registerProviders(array $providers = []): self
    {
        foreach ($providers as $provider) {
            $this->registerProvider($provider);
        }

        return $this;
    }
195560
public function registered($name)
    {
        if ($this->provider->hasSingleton($name)) {
            return $this->provider->singleton($name);
        }

        if ($this->provider->hasProvider($name)) {
            return $this->provider->getProvider($name);
        }

        return null;
    }
88486
private function ensureProviders()
	{
		if (!empty($this->lazyProviders)) {
			$this->registerProviders($this->lazyProviders);
			$this->lazyProviders = null;
		}
	}
3306
protected function registerServiceProviders()
    {
        $this->register(new EventServiceProvider($this));
        $this->register(new RoutingServiceProvider($this));

        foreach ($this->make('config')->get('app.providers') as $provider) {
            $this->register($provider);
        }
    }
324052
protected function registerProviders()
    {
        if (isset($this->container['providers'])) {
            foreach ($this->container['providers'] as $provider) {
                if (!is_subclass_of($provider, ServiceProvider::class)) {
                    throw new UnexpectedValueException($provider .
                        ' must return instance of ' . ServiceProvider::class);
                }

                (new $provider($this))->register();
            }
        }
    }
1309894
public static function providerOf($type = null)
    {
        static::registerProviders();

        if (is_null($type)) {
            return self::$provides;
        }

        if (!isset(self::$provides[$type])) {
            return array();
        }

        return self::$provides[$type];
    }