Registers the cache services in the IoC container.
347009
private function registerSingletons()
    {
        $this->app->singleton('lada.redis', function($app) {
            return new Redis();
        });

        $this->app->singleton('lada.cache', function($app) {
            return new Cache($app->make('lada.redis'), new Encoder());
        });

        $this->app->singleton('lada.invalidator', function($app) {
            return new Invalidator($app->make('lada.redis'));
        });

        $this->app->singleton('lada.handler', function($app) {
            return new QueryHandler($app->make('lada.cache'), $app->make('lada.invalidator'));
        });
    }
459042
function init(){
    if(!cacheServiceConfig) {
      cacheServiceConfig = {};
    }
    self.nameSpace = cacheServiceConfig.nameSpace || '';
    self.verbose = (typeof cacheServiceConfig.verbose === 'boolean') ? cacheServiceConfig.verbose : false;
    self.writeToVolatileCaches = (typeof cacheServiceConfig.writeToVolatileCaches === 'boolean') ? cacheServiceConfig.writeToVolatileCaches : true;
    self.caches = new CacheCollection({nameSpace: self.nameSpace, verbose: self.verbose}, cacheModules).caches;
    self.cachesLength = self.caches.length;
  }
1146006
protected function registerServices()
    {
        $this->app->bind(
            'Xuma\Amaran\ViewBinder',
            'Xuma\Amaran\AmaranViewBinder'
        );

        $this->app->singleton('amaran', function($app) {
            $binder = new AmaranViewBinder($app['events']);

            return $this->app->make('Xuma\Amaran\AmaranHandler');
        });
    }
366564
protected function registerBaseBindings()
    {
        static::setInstance($this);

        $this->instance('app', $this);

        $this->instance(Container::class, $this);

        $this->instance(PackageManifest::class, new PackageManifest(
            new Filesystem, $this->basePath(), $this->getCachedPackagesPath()
        ));
    }
838689
protected function init()
    {
        if ($this->container) {
            return;
        }

        $this->container = new Container();
        $this->connectionPool = new Pool();
        $this->cacheComponent = new CacheComponent();

        $this->container->instance(Pool::class, $this->connectionPool);
        $this->container->instance(CacheComponentInterface::class, $this->cacheComponent);
        Ioc::setContainer($this->container);

        static::$singleton = $this;
    }
577343
public function registerCoreContainerAliases()
    {
        foreach ([
                     'app' => [static::class, \Illuminate\Contracts\Container\Container::class, \Illuminate\Contracts\Foundation\Application::class, \Psr\Container\ContainerInterface::class],
                     'cache' => [\Illuminate\Cache\CacheManager::class, \Illuminate\Contracts\Cache\Factory::class],
                     'cache.store' => [\Illuminate\Cache\Repository::class, \Illuminate\Contracts\Cache\Repository::class],
                     'config' => [\Illuminate\Config\Repository::class, \Illuminate\Contracts\Config\Repository::class],
                     'encrypter' => [\Illuminate\Encryption\Encrypter::class, \Illuminate\Contracts\Encryption\Encrypter::class],
                     'db' => [\Illuminate\Database\DatabaseManager::class],
                     'db.connection' => [\Illuminate\Database\Connection::class, \Illuminate\Database\ConnectionInterface::class],
                     'events' => [\Illuminate\Events\Dispatcher::class, \Illuminate\Contracts\Events\Dispatcher::class],
                     'files' => [\Illuminate\Filesystem\Filesystem::class],
                     'filesystem' => [\Illuminate\Filesystem\FilesystemManager::class, \Illuminate\Contracts\Filesystem\Factory::class],
                     'filesystem.disk' => [\Illuminate\Contracts\Filesystem\Filesystem::class],
                     'filesystem.cloud' => [\Illuminate\Contracts\Filesystem\Cloud::class],
                     'hash' => [\Illuminate\Hashing\HashManager::class],
                     'hash.driver' => [\Illuminate\Contracts\Hashing\Hasher::class],
                     'translator' => [\Illuminate\Translation\Translator::class, \Illuminate\Contracts\Translation\Translator::class],
                     'log' => [\Illuminate\Log\LogManager::class, \Psr\Log\LoggerInterface::class],
                     'queue' => [\Illuminate\Queue\QueueManager::class, \Illuminate\Contracts\Queue\Factory::class, \Illuminate\Contracts\Queue\Monitor::class],
                     'queue.connection' => [\Illuminate\Contracts\Queue\Queue::class],
                     'queue.failer' => [\Illuminate\Queue\Failed\FailedJobProviderInterface::class],
                     'redis' => [\Illuminate\Redis\RedisManager::class, \Illuminate\Contracts\Redis\Factory::class],
                     'validator' => [\Illuminate\Validation\Factory::class, \Illuminate\Contracts\Validation\Factory::class],
                 ] as $key => $aliases) {
            foreach ($aliases as $alias) {
                $this->alias($key, $alias);
            }
        }
    }
1326504
protected function registering()
    {
        $this->app->bindShared(ServiceShortCuts::RESOLVER_SERVICE, function () {
            return new Resolver($this->app);
        });

        $this->app->bindShared(ServiceShortCuts::GHOST_SERVICE, function () {
            return new GhostServices($this->app);
        });

        $this->app->bind(ServiceShortCuts::CORE_INITIALIZED, true);

        $this->app->booting(function () {
            $loader = AliasLoader::getInstance();

            foreach ($this->aliases as $facade => $facadeClass) {
                $loader->alias($facade, $facadeClass);
            }
        });
    }
1125956
protected synchronized void initialize() {
        String invocationServiceName = this.invocationServiceName;
        invocationService = (InvocationService)
                CacheFactory.getService(invocationServiceName);
        if (invocationService == null) {
            throw new IllegalArgumentException("Invocation service ["
                                               + invocationServiceName
                                               + "] is not defined.");
        }

        invocationService.addMemberListener(this);
        serviceMembers = invocationService.getInfo().getServiceMembers();
        memberIterator = serviceMembers.iterator();
    }
1048165
public void registerService(ProvidedServiceInstance serviceInstance, ServiceInstanceHealth registryHealth) {
        registerService(serviceInstance);
        getCacheServiceInstances().put(new ServiceInstanceToken(serviceInstance.getServiceName(), serviceInstance.getProviderId()),
                new InstanceHealthPair(registryHealth));
    }
886362
public function register()
    {
        $this->registerConnectionServices();
        $this->registerEloquentFactory();
        $this->registerQueueableEntityResolver();

        Model::setConnectionResolver($this->container['db']);
        Model::setEventDispatcher($this->container['events']);
        Model::clearBootedModels();
        Model::observe(InternalObserve::class);
    }
263668
protected function registerServiceProviders()
	{
		// Core Bus
		// -----------------------------------------------------------------------------
		$this->app->register('Congraph\Core\Bus\BusServiceProvider');

		// Core Event
		// -----------------------------------------------------------------------------
		$this->app->register('Congraph\Core\Events\EventsServiceProvider');

		// Repositories
		// -----------------------------------------------------------------------------
		$this->app->register('Congraph\Core\Repositories\RepositoriesServiceProvider');
	}
550296
public void registerService(ProvidedServiceInstance serviceInstance) {
        getServiceDirectoryClient().registerServiceInstance(serviceInstance);
        getCacheServiceInstances().put(new ServiceInstanceToken(serviceInstance.getServiceName(), serviceInstance.getProviderId()), new InstanceHealthPair(null));
    }
1075691
public function register(Container $container)
    {
        $container->register(new CacheServiceProvider());
        $container->register(new DatabaseServiceProvider());
        $container->register(new FilesystemServiceProvider());
        $container->register(new LoggerServiceProvider());
        $container->register(new ScriptServiceProvider());
        $container->register(new TranslatorServiceProvider());
        $container->register(new ViewServiceProvider());

        $this->registerKernelServices($container);
        $this->registerHandlerServices($container);
        $this->registerRouteServices($container);
        $this->registerMiddlewareServices($container);
        $this->registerRequestControllerServices($container);
        $this->registerModuleServices($container);
        $this->registerViewServices($container);
    }
852386
public function registerInternalCache()
    {
        $cacheManager = $this->getCacheManager();

        if (false === $cacheManager->hasCache(self::CACHE_IDENTIFIER)) {
            $cacheManager->setCacheConfigurations([self::CACHE_IDENTIFIER => $this->cacheOptions]);
        }
    }
695798
protected function registerServices()
    {
        $services = array_filter($this->config->get('app.services'), function ($service) {
            return class_exists($service);
        });

        foreach ($services as $service) {
            /** @var \Fyuze\Kernel\Service $obj */
            $obj = new $service($this->container);
            $obj->services();

            $this->services[] = $obj;
        }
    }
1035876
public function registerConfiguredProviders()
	{
		$manifestPath = $this->getCachedServicesPath();

		(new ProviderRepository($this, new Filesystem, $manifestPath))
					->load($this->config['app.providers']);
	}
1150386
public function register()
    {
        $this->registerBindingsServiceProviderMakeCommand();
        $this->registerMakeCommand();
        $this->registerRepositoryInterfaceMakeCommand();
        $this->registerServiceMakeCommand();
        $this->registerTraitMakeCommand();
    }