Processes all context readers.

@param ContainerBuilder $container
174818
private function processContextReaders(ContainerBuilder $container)
    {
        $references = $this->processor->findAndSortTaggedServices($container, self::READER_TAG);
        $definition = $container->getDefinition(self::getEnvironmentReaderId());

        foreach ($references as $reference) {
            $definition->addMethodCall('registerContextReader', array($reference));
        }
    }
342369
private function processClassGenerator(ContainerBuilder $container)
    {
        $definition = new Definition('Drupal\DrupalExtension\Context\ContextClass\ClassGenerator');
        $container->setDefinition(ContextExtension::CLASS_GENERATOR_TAG . '.simple', $definition);
    }
183960
public function process(ContainerBuilder $container)
    {
        if ($container->hasAlias('api_platform.name_converter') || !$container->hasDefinition('serializer.name_converter.metadata_aware')) {
            return;
        }

        $definition = $container->getDefinition('serializer.name_converter.metadata_aware');

        if (1 >= \count($definition->getArguments()) || null === $definition->getArgument(1)) {
            return;
        }

        $container->setAlias('api_platform.name_converter', 'serializer.name_converter.metadata_aware');
    }
724701
public function process(ContainerBuilder $container)
    {
        $repositoryConfigurations = $container->getParameter('apisearch.repository_configuration');
        foreach ($repositoryConfigurations as $name => $repositoryConfiguration) {
            $this->createAppRepositories(
                $container,
                $name,
                $repositoryConfiguration
            );

            foreach ($repositoryConfiguration['indices'] as $indexName => $indexId) {
                $indexId = (string) $indexId;
                $this->createIndexRepositories(
                    $container,
                    $name,
                    $repositoryConfiguration,
                    $indexId,
                    $indexName
                );
            }
        }
    }
388225
public function process(ContainerBuilder $container)
    {
        $this->loader = $container->get('sulu.content.path_cleaner.replacer_loader');

        $service = $container->getDefinition('sulu.content.path_cleaner');
        $replacers = $this->loader->load($this->filename);
        $service->addArgument($replacers);
    }
683853
public function process(ContainerBuilder $container)
    {
        $this->addFilters($container, 'pre');
        $this->addFilters($container, 'post');
        $this->addFilters($container, 'output');
    }
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);
        }
    }
48808
public function process(ContainerBuilder $container): void
    {
        if ($container->has('ezpublish.fieldType.ezxmltext.converter.embedToHtml5')) {
            $container
                ->findDefinition('ezpublish.fieldType.ezxmltext.converter.embedToHtml5')
                ->setClass(EmbedToHtml5::class)
                ->addMethodCall('setSite', [new Reference('netgen.ezplatform_site.site')]);
        }
    }
964313
public function process(ContainerBuilder $container)
    {
        $compiler = $container->getCompiler();
        $formatter = $compiler->getLoggingFormatter();

        foreach ($container->getDefinitions() as $id => $definition) {
            if ($definition->isAbstract()) {
                $container->removeDefinition($id);
                $compiler->addLogMessage($formatter->formatRemoveService($this, $id, 'abstract'));
            }
        }
    }
511257
public function process(ContainerBuilder $container): void
    {
        if (true === self::enabled($container))
        {
            $excludedFiles = canonicalizeFilesPath(self::getExcludedFiles($container));

            $files = searchFiles(self::getDirectories($container), '/\.php/i');

            $this->registerClasses($container, $files, $excludedFiles);
        }
    }
379028
public function process(ContainerBuilder $container)
    {
        $this->documentMap = $container->get('graviton.document.map');

        $map = [];
        foreach ($this->documentMap->getDocuments() as $document) {
            $map[$document->getClass()] = $this->getFieldNames($document);
        }
        $container->setParameter('graviton.document.field.names', $map);
    }
105304
public function process(ContainerBuilder $container)
    {
        $wordpress = $container->getDefinition('wordpress.wordpress');
        if (! $wordpress) {
            return;
        }

        foreach ($container->findTaggedServiceIds('wordpress.element') as $id => $attributes) {
            foreach ($attributes as $attribute) {
                if (! isset($attribute['alias'], $attribute['driver'])) {
                    continue;
                }

                $wordpress->addMethodCall(
                    'registerDriverElement',
                    [$attribute['alias'], new Reference($id), $attribute['driver']]
                );
            }
        }
    }
13293
public function process(ContainerBuilder $container)
    {
        $ioMetadataHandlers = $container->hasParameter('ez_io.metadata_handlers') ?
            $container->getParameter('ez_io.metadata_handlers') :
            array();
        $this->processHandlers(
            $container,
            $container->getDefinition('ezpublish.core.io.metadata_handler.factory'),
            $ioMetadataHandlers,
            $this->metadataHandlerFactories,
            'ezpublish.core.io.metadata_handler.flysystem.default'
        );

        $ioBinarydataHandlers = $container->hasParameter('ez_io.binarydata_handlers') ?
            $container->getParameter('ez_io.binarydata_handlers') :
            array();
        $this->processHandlers(
            $container,
            $container->getDefinition('ezpublish.core.io.binarydata_handler.factory'),
            $ioBinarydataHandlers,
            $this->binarydataHandlerFactories,
            'ezpublish.core.io.binarydata_handler.flysystem.default'
        );

        // Unset parameters that are no longer required ?
    }
1321203
public function process(ContainerBuilder $container)
    {
        $parameterBag = $container->getParameterBag();

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

        $parameterReplacer->processParameterBag($parameterBag, $container);
    }
615478
public function process(ContainerBuilder $container)
    {
        $taggedServices = $container->findTaggedServiceIds(
            'elcodi.rule_context'
        );

        $contextProviders = [];
        foreach ($taggedServices as $id => $attributes) {
            $contextProviders[] = new Reference($id);
        }

        $definition = $container->getDefinition(
            'elcodi.expression_language_context_collector'
        );

        $definition->addArgument($contextProviders);
    }
46718
public function process(ContainerBuilder $container)
    {
        $fileSytem = new Filesystem(new Local(realpath($container->getParameter('kernel.root_dir') . "/../var")));
        $fileSytem->createDir('expansion');
        $fileSytem = new Filesystem(new Local(realpath($container->getParameter('kernel.root_dir') . "/../var/expansion")));

        $this->fetchDataFromRemote($fileSytem, $container);

        if ($fileSytem->has(self::MAPPINGS_FILE)) {
            $data = json_decode($fileSytem->read(self::MAPPINGS_FILE), true);
            if ($data) {
                $values = [];
                foreach ($data as $titleId => $titleInformation) {
                    $values[$titleId] = $titleInformation['game'];
                }

                $container->setParameter("expansion.storage.gamedata.titles", $values);
            }
        }
    }
701953
public function process(ContainerBuilder $container)
    {
        $this->container = $container;
        $this->graph = $container->getCompiler()->getServiceReferenceGraph();
        $this->graph->clear();
        $this->lazy = false;
        $this->byConstructor = false;
        $this->definitions = $container->getDefinitions();
        $this->aliases = $container->getAliases();

        foreach ($this->aliases as $id => $alias) {
            $targetId = $this->getDefinitionId((string) $alias);
            $this->graph->connect($id, $alias, $targetId, null !== $targetId ? $this->container->getDefinition($targetId) : null, null);
        }

        try {
            parent::process($container);
        } finally {
            $this->aliases = $this->definitions = [];
        }
    }