private void configureRuntimeConfig()

in impl/src/main/java/org/apache/myfaces/config/FacesConfigurator.java [804:1038]
202 lines of code
34 McCabe index (conditional complexity)

    private void configureRuntimeConfig()
    {
        RuntimeConfig runtimeConfig = RuntimeConfig.getCurrentInstance(_externalContext);
        FacesConfigData dispenser = getDispenser();
        List<String> knownNamespaces = new ArrayList<>();
        
        for (ComponentTagDeclaration declaration : dispenser.getComponentTagDeclarations())
        {
            runtimeConfig.addComponentTagDeclaration(declaration);
            if (declaration.getNamespace() != null)
            {
                knownNamespaces.add(declaration.getNamespace());
            }
        }

        for (NavigationRule rule : dispenser.getNavigationRules())
        {
            runtimeConfig.addNavigationRule(rule);
        }

        for (String converterClassName : dispenser.getConverterConfigurationByClassName())
        {
            runtimeConfig.addConverterConfiguration(converterClassName,
                    _dispenser.getConverterConfiguration(converterClassName));
        }

        for (ResourceBundle bundle : dispenser.getResourceBundles())
        {
            runtimeConfig.addResourceBundle(bundle);
        }

        for (String className : dispenser.getElResolvers())
        {
            ELResolver elResolver = (ELResolver) ClassUtils.newInstance(className, ELResolver.class);
            _callInjectAndPostConstruct(elResolver);
            runtimeConfig.addFacesConfigElResolver(elResolver);
        }
        
        for (String className : dispenser.getSearchKeywordResolvers())
        {
            SearchKeywordResolver searchKeywordResolver = (SearchKeywordResolver) ClassUtils.newInstance(
                    className, SearchKeywordResolver.class);
            
            runtimeConfig.addApplicationSearchExpressionResolver(searchKeywordResolver);
        }

        runtimeConfig.setFacesVersion(dispenser.getFacesVersion());

        runtimeConfig.setNamedEventManager(new NamedEventManager());

        for (NamedEvent event : dispenser.getNamedEvents())
        {
            try
            {
                Class<? extends ComponentSystemEvent> clazz = ClassUtils.classForName(event.getEventClass());
                runtimeConfig.getNamedEventManager().addNamedEvent(event.getShortName(), clazz);
            }
            catch (ClassNotFoundException e)
            {
                log.log(Level.SEVERE, "Named event could not be initialized, reason:", e);
            }
        }

        String elResolverComparatorClass = _myfacesConfig.getElResolverComparator();
        if (elResolverComparatorClass != null && !elResolverComparatorClass.isEmpty())
        {
            try
            {
                Class<Comparator<ELResolver>> clazz = ClassUtils.classForName(elResolverComparatorClass);
                Comparator<ELResolver> comparator = ClassUtils.newInstance(clazz);
                runtimeConfig.setELResolverComparator(comparator);
            }
            catch (Exception e)
            {
                if (log.isLoggable(Level.SEVERE))
                {
                    log.log(Level.SEVERE, "Cannot instantiate EL Resolver Comparator " + elResolverComparatorClass
                            + " . Check " + MyfacesConfig.EL_RESOLVER_COMPARATOR + " web config param. "
                            + "Initialization continues with no comparator used.", e);
                }
            }
        }
        else
        {
            runtimeConfig.setELResolverComparator(null);
        }

        String elResolverPredicateClass = _myfacesConfig.getElResolverPredicate();
        if (elResolverPredicateClass != null && !elResolverPredicateClass.isEmpty())
        {
            try
            {
                Class<?> clazz = ClassUtils.classForName(elResolverPredicateClass);
                Object elResolverPredicate = ClassUtils.newInstance(clazz);
                if (elResolverPredicate instanceof Predicate predicate)
                {
                    runtimeConfig.setELResolverPredicate(predicate);
                }
                else
                {
                    if (log.isLoggable(Level.SEVERE))
                    {
                        log.log(Level.SEVERE, "EL Resolver Predicate " + elResolverPredicateClass
                                + " must implement " + Predicate.class.getName()
                                + " . Check " + MyfacesConfig.EL_RESOLVER_PREDICATE + " web config param. "
                                + "Initialization continues with no predicate used.");
                    }
                }
            }
            catch (Exception e)
            {
                if (log.isLoggable(Level.SEVERE))
                {
                    log.log(Level.SEVERE, "Cannot instantiate EL Resolver Predicate " + elResolverPredicateClass
                            + " . Check " + MyfacesConfig.EL_RESOLVER_PREDICATE + " web config param. "
                            + "Initialization continues with no predicate used.", e);
                }
            }
        }
        else
        {
            runtimeConfig.setELResolverPredicate(null);
        }

        for (FaceletsProcessing faceletsProcessing : dispenser.getFaceletsProcessing())
        {
            runtimeConfig.addFaceletProcessingConfiguration(faceletsProcessing.getFileExtension(), faceletsProcessing);
        }
        
        ResourceLibraryContractsProvider rlcp = ResourceLibraryContractsProviderFactory.
            getFacesConfigResourceProviderFactory(_externalContext).
            createResourceLibraryContractsProvider(_externalContext);
        
        try
        {
            // Faces 2.2 section 11.4.2.1 scan for available resource library contracts
            // and store the result in a internal data structure, so it can be used 
            // later in ViewDeclarationLanguage.calculateResourceLibraryContracts(
            //   FacesContext context, String viewId)
            runtimeConfig.setExternalContextResourceLibraryContracts(
                rlcp.getExternalContextResourceLibraryContracts(_externalContext));
            runtimeConfig.setClassLoaderResourceLibraryContracts(
                rlcp.getClassloaderResourceLibraryContracts(_externalContext));
        }
        catch (Exception e)
        {
            if (log.isLoggable(Level.SEVERE))
            {
                log.log(Level.SEVERE, 
                    "An error was found when scanning for resource library contracts", e);
            }
        }
        
        
        // Faces 2.2 section 11.4.2.1 check all contracts are loaded
        if (log.isLoggable(Level.INFO))
        {
            for (List<String> list : runtimeConfig.getContractMappings().values())
            {
                for (String contract : list)
                {
                    if (!runtimeConfig.getResourceLibraryContracts().contains(contract))
                    {
                        log.log(Level.INFO, 
                            "Resource Library Contract "+ contract + " was not found while scanning for "
                            + "available contracts.");
                    }
                }
            }
        }
        
        // Faces 2.2 section 11.4.2.1 if no contractMappings set, all available contracts applies
        // to all views.
        if (runtimeConfig.getContractMappings().isEmpty())
        {
            String[] contracts = runtimeConfig.getResourceLibraryContracts().toArray(
                new String[runtimeConfig.getResourceLibraryContracts().size()]);
            runtimeConfig.addContractMapping("*", contracts);
        }
        
        for (String resourceResolver : dispenser.getResourceResolvers())
        {
            runtimeConfig.addResourceResolver(resourceResolver);
        }
        
        for (FaceletTagLibrary faceletTagLibrary : dispenser.getTagLibraries())
        {
            runtimeConfig.addFaceletTagLibrary(faceletTagLibrary);
            if (faceletTagLibrary.getNamespace() != null)
            {
                knownNamespaces.add(faceletTagLibrary.getNamespace());
            }
        }
        
        // Add default namespaces to the known namespaces
        knownNamespaces.add("http://xmlns.jcp.org/jsf/core");
        knownNamespaces.add("http://java.sun.com/jsf/core");
        knownNamespaces.add("http://xmlns.jcp.org/jsf/html");
        knownNamespaces.add("http://java.sun.com/jsf/html");
        knownNamespaces.add("http://xmlns.jcp.org/jsf/facelets");
        knownNamespaces.add("http://java.sun.com/jsf/facelets");
        knownNamespaces.add("http://xmlns.jcp.org/jsp/jstl/core");
        knownNamespaces.add("http://java.sun.com/jsp/jstl/core");
        knownNamespaces.add("http://java.sun.com/jstl/core");
        knownNamespaces.add("http://xmlns.jcp.org/jsp/jstl/functions");
        knownNamespaces.add("http://java.sun.com/jsp/jstl/functions");
        knownNamespaces.add("http://xmlns.jcp.org/jsf/composite");
        knownNamespaces.add("http://java.sun.com/jsf/composite");
        knownNamespaces.add("http://xmlns.jcp.org/jsf");
        knownNamespaces.add("http://java.sun.com/jsf");
        knownNamespaces.add("http://xmlns.jcp.org/jsf/passthrough");
        knownNamespaces.add("http://java.sun.com/jsf/passthrough");
        
        Map<Integer, String> namespaceById = new HashMap<>();
        Map<String, Integer> idByNamespace = new HashMap<>();
        // Sort them to ensure the same id 
        Collections.sort(knownNamespaces);
        for (int i = 0; i < knownNamespaces.size(); i++)
        {
            namespaceById.put(i, knownNamespaces.get(i));
            idByNamespace.put(knownNamespaces.get(i), i);
        }
        runtimeConfig.setNamespaceById(Collections.unmodifiableMap(namespaceById));
        runtimeConfig.setIdByNamespace(Collections.unmodifiableMap(idByNamespace));
        
        for (ViewPoolMapping viewPoolMapping : dispenser.getViewPoolMappings())
        {
            runtimeConfig.addViewPoolMapping(viewPoolMapping);
        }
        
        for (FaceletsTemplateMapping faceletsTemplateMapping : dispenser.getFaceletsTemplateMappings())
        {
            runtimeConfig.addFaceletsTemplateMapping(faceletsTemplateMapping);
        }
    }