register new providers or something

@throws ProviderException
@return mixed
331509
public function boot()
    {
        $this->getContainer()
            ->addProvider(ArraySerializerProvider::class)
            ->addProvider(JsonSerializerProvider::class)
            ->addProvider(CompressorProvider::class)
            ->addProvider(ArrayCacheDriver::class);
    }
199737
public function register()
    {
        $this->mergeConfigFrom(__DIR__ . '/../../../config/settings.php', 'settings');

        $this->app->singleton('settings.key_generator', function ($app) {
            return $app->make($app['config']['settings.key_generator']);
        });

        $this->app->singleton('settings.context_serializer', function ($app) {
            return $app->make($app['config']['settings.context_serializer']);
        });

        $this->app->singleton('settings.value_serializer', function ($app) {
            return $app->make($app['config']['settings.value_serializer']);
        });

        $this->app->singleton('settings.factory', function ($app) {
            return new Factory($app);
        });

        $this->app->singleton('settings.repository', function ($app) {
            return $app['settings.factory']->driver();
        });

        $this->app->singleton('settings', function ($app) {
            $settings = new Settings(
                $app['settings.repository'],
                $app['settings.key_generator'],
                $app['settings.value_serializer']
            );

            $settings->setCache($app['cache.store']);
            $settings->setEncrypter($app['encrypter']);
            $settings->setDispatcher($app['events']);

            $app['config']['settings.cache'] ? $settings->enableCache() : $settings->disableCache();
            $app['config']['settings.encryption'] ? $settings->enableEncryption() : $settings->disableEncryption();
            $app['config']['settings.events'] ? $settings->enableEvents() : $settings->disableEvents();

            return $settings;
        });

        $this->registerAliases();

        $this->registerCommands();
    }
1015168
public function registerServices()
    {
        $this['serviceProviders'] = $this->serviceProviders;

        foreach ($this->serviceProviders as $providerArray) {
            list($provider,$enabled) = $providerArray;

            if (!$enabled) {
                continue;
            }

            if (empty($provider) || !class_exists($provider)) {
                continue;
            }

            $provider = new $provider(self::$instance);
            $provider->register();
        }
    }
979851
public function registerConfiguredProviders(){
			//Count Providers Array in Config
		if (is_array($this['config']->get('plugin.providers'))) {
			foreach ($this['config']->get('plugin.providers') as $index => $namespace) {
				$this->register($namespace);
			}
		}
	}
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();
        }
    }
679237
private function registerProvider()
    {
        $app = $this->app;

        // Pick the correct service provider for the current verison of Laravel
        $this->provider = (version_compare($app::VERSION, '5.0', '<'))
            ? new TmdbServiceProviderLaravel4($app)
            : new TmdbServiceProviderLaravel5($app);
    }
561719
public function providers(array $providers = [])
    {
        foreach ($providers as $provider) {
            $this->app->register(new $provider($this->app));
        }

        return $this;
    }
144652
public function register()
    {
        // Registrar binds
        foreach ($this->binds as $bindId => $bindClass)
            $this->app->bind($bindId, $bindClass);

        // Registrar providers
        foreach ($this->providers as $provider => $classServiceProvider)
        {
            $this->app->singleton($provider, function ($app) use ($classServiceProvider) {
                return new $classServiceProvider($app);
            });
        }
    }
1192297
public function registerConfiguredProviders()
    {
        $providers = $this['config']->get('app.providers', []);

        foreach ($providers as $provider) {
            $this->register(new $provider($this));
        }
    }
815958
protected function registerDefaultProviders() {

		array_map( function( $provider ) {
			$this->provider( $provider );
		}, [
			AttrServiceProvider::class,
			LanguageServiceProvider::class,
			MetaServiceProvider::class,
			TemplatesServiceProvider::class,
			HierarchyServiceProvider::class,
			ViewServiceProvider::class
		] );
	}
1198432
public function registerConfiguredProviders()
	{
		$manifestPath = $this->basePath() . '/vendor/services.json';

		(new ProviderRepository($this, new Filesystem, $manifestPath))
		            ->load($this->config['app.providers']);
	}
1293073
public function registerConfiguredProviders()
    {
        foreach ([
                     CacheProvider::class,
                     PartProvider::class,
                     SchedulingProvider::class,
                     ViewProvider::class,
                     EventProvider::class,
                     DatabaseProvider::class,
                     LogProvider::class,
                     HttpProvider::class,
                     SocketProvider::class,

                     ExtendProvider::class,
                 ] as $provider) {
            $this->register($provider);
        }
    }
115481
public function registerProvider(Provider $provider)
    {
        $provider->register($this);
        
        $this->container->addProvider($provider);
        
        return $this;
    }
1233839
public function registerDefaultProviders()
    {
        $this->providers = array(
            new Provider\Flickr(),
            new Provider\Hulu(),
            new Provider\iFixit(),
            new Provider\PollEverywhere(),
            new Provider\Qik(),
            new Provider\Revision3(),
            new Provider\SlideShare(),
            new Provider\SmugMug(),
            new Provider\Viddler(),
            new Provider\Vimeo(),
            new Provider\YouTube(),
        );

        return $this;
    }
701662
public function addProvider($provider)
    {
        if (is_string($provider)) {
            $provider = new $provider($this);
        }

        // Only allow a service provider to be registered
        // once.
        if (in_array($provider, $this->providers)) {
            return;
        }

        $this->providers[] = $provider;

        $this->registerEvents($provider);
        $this->registerProvides($provider);

        $this->registerProvider($provider);
    }
44081
public function register()
    {
        // Bind the Adldap contract to the Adldap object
        // in the IoC for dependency injection.
        $this->app->singleton(AdldapInterface::class, function (Container $app) {
            $config = $app->make('config')->get('ldap');

            // Verify configuration exists.
            if (is_null($config)) {
                $message = 'Adldap configuration could not be found. Try re-publishing using `php artisan vendor:publish`.';

                throw new \RuntimeException($message);
            }

            return $this->addProviders($this->newAdldap(), $config['connections']);
        });
    }
57230
public function register()
    {
        $this->getContainer()->singleton(Annotation::class, function() {
            Annotation::setContainer($this->getContainer());

            $annotation =  new Annotation((new Parser())->skipPhpDoc());

            return $annotation->addCommand(new Inject())
                ->addCommand(new Provider());
        });
    }