@param LimoncelloContainerInterface $container

@return void
487670
public static function configureExceptionHandler(LimoncelloContainerInterface $container)
    {
        $container[ThrowableHandlerInterface::class] = function (PsrContainerInterface $container) {
            /** @var CacheSettingsProviderInterface $provider */
            $provider      = $container->get(CacheSettingsProviderInterface::class);
            $appConfig     = $provider->getApplicationConfiguration();
            $fluteSettings = $provider->get(FluteSettings::class);

            $isLogEnabled = $appConfig[A::KEY_IS_LOG_ENABLED];
            $isDebug      = $appConfig[A::KEY_IS_DEBUG];

            $ignoredErrorClasses = $fluteSettings[FluteSettings::KEY_DO_NOT_LOG_EXCEPTIONS_LIST__AS_KEYS];
            $codeForUnexpected   = $fluteSettings[FluteSettings::KEY_HTTP_CODE_FOR_UNEXPECTED_THROWABLE];
            $throwableConverter  =
                $fluteSettings[FluteSettings::KEY_THROWABLE_TO_JSON_API_EXCEPTION_CONVERTER] ?? null;

            /** @var EncoderInterface $encoder */
            $encoder = $container->get(EncoderInterface::class);

            $handler = new FluteThrowableHandler(
                $encoder,
                $ignoredErrorClasses,
                $codeForUnexpected,
                $isDebug,
                $throwableConverter
            );

            if ($isLogEnabled === true && $container->has(LoggerInterface::class) === true) {
                /** @var LoggerInterface $logger */
                $logger = $container->get(LoggerInterface::class);
                $handler->setLogger($logger);
            }

            return $handler;
        };
    }
357690
protected function callAfterCallbacks(Container $container)
	{
		foreach ($this->afterCallbacks as $callback)
		{
			$container->call($callback);
		}
	}
1271601
public function process(ContainerBuilder $container)
    {
        $this->processDriverPass($container);
        $this->processDriverElementPass($container);
        $this->processEventSubscriberPass($container);
        $this->processClassGenerator($container);

        $this->setPageObjectNamespaces($container);
        $this->injectSiteUrlIntoPageObjects($container);
    }
683853
public function process(ContainerBuilder $container)
    {
        $this->addFilters($container, 'pre');
        $this->addFilters($container, 'post');
        $this->addFilters($container, 'output');
    }
673804
static public function run(ContainerInterface $container)
    {
        $request = ServerRequestFactory::fromGlobals();
        $container->set('Request', $request);
        $response = $container->get('HttpDispatcher')->dispatch($request);

        if (is_null($response)) {
            $controller = new Controller($container);
            $response = new TextResponse('Internal server error. Dispatcher returned null response.', 500);
        }

        (new SapiEmitter())->emit($response);
    }
669578
public function addContainer(ContainerInterface $container)
    {
        $container->setDelegator($this);
        $this->containers[] = $container;
        return $this;
    }
494392
public function addContainer(MutableContainerInterface $container): void
    {
        $containerName = get_class($container);
        if (array_key_exists($containerName, $this->registry)) {
            throw new ContainerAlreadyRegisteredException($containerName);
        }

        $this->registry[$containerName] = $container;
    }
1192812
private static function injectContainerToMigrations(ContainerInterface $container, array $versions) : void
    {
        foreach ($versions as $version) {
            $migration = $version->getMigration();
            if (! ($migration instanceof ContainerAwareInterface)) {
                continue;
            }

            $migration->setContainer($container);
        }
    }
297857
public function process(ContainerBuilder $container)
    {
        if (
            !$container->hasDefinition(self::VIEW_BUILDER_REGISTRY)
            || !$container->hasDefinition(self::VIEW_BUILDER_CONTENT_TRANSLATE)
        ) {
            return;
        }

        $registry = $container->findDefinition(self::VIEW_BUILDER_REGISTRY);

        $viewBuilders = [
            $container->getDefinition(self::VIEW_BUILDER_CONTENT_TRANSLATE),
        ];

        $registry->addMethodCall('addToRegistry', [$viewBuilders]);
    }
181388
public function migrate(ContainerInterface $container): void
    {
        foreach ($this->getMigrations($container) as $class) {
            assert(is_string($class));
            $this->getIO()->writeInfo("Starting migration for `$class`..." . PHP_EOL, IoInterface::VERBOSITY_VERBOSE);
            if (($migration = $this->createMigration($class, $container)) !== null) {
                $migration->init($container)->migrate();
                $this->getIO()->writeInfo("Migration finished for `$class`." . PHP_EOL, IoInterface::VERBOSITY_NORMAL);
            }
        }
    }
848346
protected function injectPackages(ContainerInterface $container)
	{
		foreach ($this->getPackages() as $package) {
			$package->inject($container);
		}
	}
1301162
public function handleDependencies(DependencyContainerInterface $container): DependencyContainerInterface
    {
        $container[self::COMMAND_COLLECTION] = function () {
            return new CommandCollection(
                $this->getCommandList()
            );
        };

        return $container;
    }
283090
public function process(ContainerBuilder $container): void
    {
        if ($container->has('ezpublish.image_alias.imagine.cache_resolver')) {
            $container
                ->findDefinition('ezpublish.image_alias.imagine.cache_resolver')
                ->setClass(IORepositoryResolver::class);
        }
    }
735035
public function process(ContainerBuilder $container)
    {
        if ($container->has('security.authentication.success_handler')) {
            $container
                ->findDefinition('security.authentication.success_handler')
                ->setClass(AuthenticationSuccessHandler::class);
        }

        if ($container->has('security.authentication.provider.dao')) {
            $container
                ->findDefinition('security.authentication.provider.dao')
                ->setClass(DaoAuthenticationProvider::class);
        }

        if ($container->has('sylius.authentication.success_handler')) {
            $container
                ->findDefinition('sylius.authentication.success_handler')
                ->setClass(AuthenticationSuccessHandler::class);
        }
    }
1035063
public static function configureContainer(LimoncelloContainerInterface $container): void
    {
        $container[AnalyzerInterface::class] = function (PsrContainerInterface $container) {
            $settingsProvider = $container->get(SettingsProviderInterface::class);

            [$corsSettings, $isLogEnabled] = $settingsProvider->get(C::class);

            $analyzer = Analyzer::instance((new Settings())->setData($corsSettings));

            if ($isLogEnabled === true && $container->has(LoggerInterface::class)) {
                $logger = $container->get(LoggerInterface::class);
                $analyzer->setLogger($logger);
            }

            return $analyzer;
        };
    }
739713
public function process(ContainerBuilder $container)
    {
        $this->setFactoryAndServerClasses($container);
        parent::process($container);
        $this->setCasServerConfig($container);
    }
1192067
public function handle(Container $container)
    {
        $class = new \ReflectionClass(get_class($this->methodInvocation->getThis()));
        if ($class->getFileName()) {
            $method = $this->methodInvocation->getMethod()->getName();
            $container->call(
                [
                    $this->methodInvocation->getThis(),
                    $method,
                ],
                $this->methodInvocation->getArguments()->getArrayCopy()
            );
        }
    }