Register a single provider. This could be a Resource Provider or a "plain" provider not associated with any
resource.
502831
public void registerProvider(Object provider) {
		if (provider != null) {
			Collection<Object> providerList = new ArrayList<>(1);
			providerList.add(provider);
			registerProviders(providerList);
		}
	}
258612
def register(self, collector):
        
        if not isinstance(collector, Collector):
            raise TypeError(
                "Can't register instance, not a valid type of collector")

        if collector.name in self.collectors:
            raise ValueError("Collector already exists or name colision")

        with mutex:
            self.collectors[collector.name] = collector
412117
@Override
  public void register(final String name, final boolean isDefault, final LoggerProvider loggerProvider) {
    final boolean actualDefault = loggerProviderKeeper.findDefault() == null ? true : isDefault;
    loggerProviderKeeper.keep(name, actualDefault, loggerProvider);
    this.defaultLogger = loggerProviderKeeper.findDefault().logger();
  }
1408
function registerProviders () {
  Object.keys(settings.providers).forEach(function (id) {
    var providerConf = settings.providers[id]
    var provider = providers[id] ? providers[id] : providerConf

    var strategy = protocols.initialize(id, provider, providerConf)
    strategies[id] = strategy
  })
}
1248162
public function register($provider, $options = [], $force = false)
    {
        if (! $provider instanceof ServiceProvider) {
            $provider = $this->resolveProvider($provider);
        }

        if (\array_key_exists($providerName = \get_class($provider), $this->loadedProviders)) {
            return;
        }

        $this->loadedProviders[$providerName] = $provider;

        if (\method_exists($provider, 'register')) {
            $provider->register();
        }

        if ($this->booted) {
            $this->bootProvider($provider);
        }
    }
224132
public function register() : void
    {
        $environment = $this->app->environment();

        $providers = $this->app['config']->get('app.' . $environment . '_providers', []);

        foreach ($providers as $provider) {
            $this->app->register($provider);
        }

        $facades = $this->app['config']->get('app.' . $environment . '_aliases', []);

        foreach ($facades as $class => $name) {
            AliasLoader::getInstance()->alias($class, $name);
        }
    }
24141
protected function registerAdditionalProviders()
    {
        foreach ($this->providers as $provider) {
            if (class_exists($provider)) {
                $this->app->register($provider);
            }
        }
    }
668915
public void registerAuthenticationProvider(Class<? extends AuthenticationProvider> providerClass) {
    AuthenticationProvider provider = instantiateProvider(providerClass);
    authenticationProviders.put(provider.getName(), providerClass);  
    credentialAuths.put(provider.getName(), provider.requiresCredentials());
  }
1311195
public <T extends InvocationMarshaller<?>> T registerProvider (
        InvocationProvider provider, Class<T> mclass)
    {
        return registerProvider(provider, mclass, null);
    }
1192297
public function registerConfiguredProviders()
    {
        $providers = $this['config']->get('app.providers', []);

        foreach ($providers as $provider) {
            $this->register(new $provider($this));
        }
    }
282245
public static void registerProvider( String providerName, Class<? extends StorageProvider> providerClass )
    {
        if ( PROVIDERS.containsKey( providerName ) ) {
            throw new IllegalArgumentException( "A provider already exists with the name " + providerName );
        }
        PROVIDERS.put( providerName, providerClass );
        LOGGER.debug( "Registering new provider: {}", providerClass.getSimpleName() );
    }
618129
public final void register() {
        synchronized (lock) {
            if (serviceRegistration == null) {
                BundleClassResolver resolver = new BundleClassResolver();
                serviceRegistration = bundleContext.registerService(SERVICE_NAMES, resolver, serviceProperties);
            }
        }
    }
576864
def register(cls, instance_class, name=None):
        
        if name is None:
            name = instance_class.__name__
        cls.INSTANCE_CLASSES[name] = instance_class
1138545
public function register($provider, $options = [], $force = false){
		if(!isset($this->providers[$provider]) || $force){
			$this->providers[$provider] = new $provider($this,$options);
			with($this->providers[$provider])->register();
		}
	}
1101271
def unregister(self, provider):
        '''
        '''
        if isinstance(provider, type):
            provider = provider()
        if isinstance(provider, DataProvider):
            provider = provider.code
        return self.pop(str(provider).upper(), None)
1290693
private function registerProviders(): void
    {
        $this->providers = array_merge($this->providers, $this->getConfigProviders());

        foreach ($this->providers as $provider) {
            $provider = $this->container->get($provider);
            $provider->boot();
        }
    }
1255106
public function registerProvider($provider){
        $providers = (array) $provider;

        foreach($providers as $provider){
            $this->app()['config']->add('general.providers', $provider);
        }
    }