Registers the monolog handler in all channels

@param ContainerBuilder $container
421010
private function registerMonologHandlerInAllChannels (ContainerBuilder $container)
    {
        $monitoringReference = new Reference(self::MONOLOG_HANDLER_SERVICE_ID);

        // push reference as handler to every logger in the system
        foreach ($container->getDefinitions() as $key => $definition)
        {
            if (0 === strpos($key, "monolog.logger."))
            {
                $definition->addMethodCall("pushHandler", [$monitoringReference]);
            }
        }
    }
1243144
public function process(ContainerBuilder $container)
    {
        if (!$container->hasDefinition("thelia.parser")) {
            return;
        }

        $smarty = $container->getDefinition("thelia.parser");

        foreach ($container->findTaggedServiceIds("thelia.parser.register_plugin") as $id => $plugin) {
            $smarty->addMethodCall("addPlugins", array(new Reference($id)));
        }

        $smarty->addMethodCall("registerPlugins");
    }
404700
public function process(ContainerBuilder $container)
    {
        if (!$container->hasDefinition('drupal.event_dispatcher')) {
            return;
        }
        $dispatcherDefinition = $container->getDefinition('drupal.event_dispatcher');

        foreach ($container->findTaggedServiceIds('drupal.event_subscriber') as $id => $attributes) {
            foreach ($attributes as $attribute) {
                $priority = isset($attribute['priority']) ? intval($attribute['priority']) : 0;
                $dispatcherDefinition->addMethodCall(
                    'addSubscriber',
                    array(new Reference($id), $priority)
                );
            }
        }
    }
979932
public function process(ContainerBuilder $container)
    {
        $this->container = $container;
        $this->signalingException = new RuntimeException('Invalid reference.');

        try {
            $this->processValue($container->getDefinitions(), 1);
        } finally {
            $this->container = $this->signalingException = null;
        }
    }
1073975
public function register(Container $container)
    {
        $container['extensions.sections'] = function ($c) {
            return new Sections($c['section.factory'], $c['events']);
        };

        $container['extensions.helpers'] = function ($c) {
            return new Helpers($c['escaper'], $c['options']);
        };

        $container['extensions.walker'] = function ($c) {
            return new Walker($c['command'], $c['escaper'], $c['options']);
        };

        $container['extensions.filters'] = function () {
            return new Filters();
        };

        $container['extensions.aura_html'] = function ($c) {
            return new AuraHtmlExtension(
                $c['aura.html.locator'],
                $c['options']['html_tags_functions']
            );
        };
    }
472167
protected function registerWidget(ContainerBuilder $container)
    {
        $templatingEngines = $container->getParameter("templating.engines");

        if (in_array("php", $templatingEngines)) {
            $formRessource = "VihuvacRecaptchaBundle:Form";

            $container->setParameter("templating.helper.form.resources", array_merge(
                $container->getParameter("templating.helper.form.resources"),
                array($formRessource)
            ));
        }

        if (in_array("twig", $templatingEngines)) {
            $formRessource = "VihuvacRecaptchaBundle:Form:vihuvac_recaptcha_widget.html.twig";

            $container->setParameter("twig.form.resources", array_merge(
                $container->getParameter("twig.form.resources"),
                array($formRessource)
            ));
        }
    }
1321203
public function process(ContainerBuilder $container)
    {
        $parameterBag = $container->getParameterBag();

        $parameterReplacer = $container->get(ServiceNames::PARAMETER_REPLACER);

        $parameterReplacer->processParameterBag($parameterBag, $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]);
    }
885116
public function register( Container $container ) {
		$this->container = $container;

		$container->define(
			array( 'assets' => 'Intraxia\Jaxion\Contract\Assets\Register' ),
			$register = new Register( $container->fetch( 'url' ), $container->fetch( 'version' ) )
		);

		$this->add_assets( $register );
	}
184579
public function process(ContainerBuilder $container): void
    {
        $loggerDefinition = $container->getDefinition('service_bus.logger');

        if (NullLogger::class === $loggerDefinition->getClass())
        {
            $loggerDefinition->setClass(Logger::class);
            $loggerDefinition->setArguments(['%service_bus.entry_point%']);
        }

        $processors = [
            PsrLogMessageProcessor::class,
            MemoryUsageProcessor::class,
            ProcessIdProcessor::class,
        ];

        foreach ($processors as $processor)
        {
            $container->addDefinitions([$processor => new Definition($processor)]);
            $loggerDefinition->addMethodCall(
                'pushProcessor',
                [new Reference($processor)]
            );
        }
    }
1308582
public function build(ContainerBuilder $container)
    {
        $container->addCompilerPass(
            new GenericCompilerPass(
                FilterTypeRegistry::class,
                'sidus.filter_type',
                'addFilterType'
            )
        );
        $container->addCompilerPass(
            new GenericCompilerPass(
                QueryHandlerRegistry::class,
                'sidus.query_handler_factory',
                'addQueryHandlerFactory'
            )
        );
    }
690980
public function register(Container $container)
    {
        $this->registerViewConfig($container);
        $this->registerLoaderServices($container);
        $this->registerEngineServices($container);
        $this->registerMustacheTemplatingServices($container);
        $this->registerTwigTemplatingServices($container);
        $this->registerViewServices($container);
    }
769865
public function register(Container $container)
    {
        $container->share(\Swift_Mailer::class, [$this, 'swiftmailer'])
            ->alias('swiftmailer', \Swift_Mailer::class);

        $container->bindShared(MailerAdapterInterface::class, SwiftMailerAdapter::class)
            ->alias('mailer.adapter.swiftmailer', SwiftMailerAdapter::class);
    }
262321
public function register(Container $container)
    {
        // Get cache factory object.
        $container->prepareSharedObject(CacheManager::class);

        // Get global cache object.
        $container->share(Cache::class, function (Container $container) {
            /** @var Structure $config */
            $config = $container->get('config');

            $storage = $config->get('cache.storage', 'file');
            $handler = $config->get('cache.serializer', 'php');

            return $container->get(CacheManager::class)->create('windwalker', $storage, $handler);
        });
    }
1175527
public function register(Container $container)
    {
        $container->share(HandlerInterface::class, [$this, 'handler']);
        $container->share(AbstractDatabaseAdapter::class, [$this, 'dbAdapter']);

        $container->bind(SessionBagInterface::class, SessionBag::class);
        $container->bind(FlashBagInterface::class, FlashBag::class);
        $container->bind(SessionBridgeInterface::class, NativeBridge::class);

        $closure = function (Container $container) {
            /** @var \Windwalker\Structure\Structure $config */
            $config = $container->get('config');
            $uri    = $container->get('uri');

            $options = (array) $config->get('session', []);

            $options['cookie_path']   = !empty($options['cookie_path']) ? $options['cookie_path'] : $uri->path;
            $options['cookie_domain'] = parse_url($uri->host, PHP_URL_HOST);

            return $container->newInstance(Session::class, ['options' => $options]);
        };

        $container->share(Session::class, $closure);
    }
140012
public function register(Container $container)
    {
        $container->prepareSharedObject(RendererManager::class, [$this, 'manager']);
        $container->prepareSharedObject(PackageFinder::class);
        $container->share(WidgetManager::class, [$this, 'widget']);
    }
1279698
public function register(Container $container)
    {
        /** @var Config $configuration */
        $configuration = $container['config'];

        /** @var LoggerInterface $logger */
        $logger = $container['logger'];

        /** @var Client $http */
        $http = $container['http'];

        /** @var TierConfiguration $tierConfiguration */
        $tierConfiguration = $container['tierConfiguration'];

        /** @var Fulfillment $fulfillment */
        $fulfillment = $container['fulfillment'];

        return new Usage($configuration, $logger, $http, $tierConfiguration, $fulfillment);
    }