class ApplicationRuntimeModel implements IsleDeploymentModel {

    public static final String                      APPLICATION_RUNTIME_MODEL_NAME = "APPLICATION_RUNTIME_MODEL";

    @Deprecated
    public static final String                      APPLICATION                    = "SOFABOOT-APPLICATION";
    /** deploys */
    private final List<DeploymentDescriptor>        deploys                        = new ArrayList<>();
    /** inactive deploys */
    private final List<DeploymentDescriptor>        inactiveDeploys                = new ArrayList<>();
    /** failed deployments */
    private final List<DeploymentDescriptor>        failed                         = new CopyOnWriteArrayList<>();
    /** installed deployments */
    private final List<DeploymentDescriptor>        installed                      = new CopyOnWriteArrayList<>();
    /** module name to deployment */
    private final Map<String, DeploymentDescriptor> deploymentMap                  = new LinkedHashMap<>();
    /** deploy registry */
    private final DeployRegistry                    deployRegistry                 = new DeployRegistry();
    /** no spring powered deploys name*/
    private final Set<String>                       noSpringPoweredDeploys         = new HashSet<>();
    /** module deployment validator */
    private ModuleDeploymentValidator               moduleDeploymentValidator;
    /** module profiles checker */
    protected SofaModuleProfileChecker              sofaModuleProfileChecker;
    /** resolved deployments */
    private List<DeploymentDescriptor>              resolvedDeployments;

    public boolean isModuleDeployment(DeploymentDescriptor deploymentDescriptor) {
        return this.moduleDeploymentValidator.isModuleDeployment(deploymentDescriptor);
    }

    public boolean acceptModule(DeploymentDescriptor deploymentDescriptor) {
        return this.sofaModuleProfileChecker.acceptModule(deploymentDescriptor);
    }

    public DeploymentDescriptor addDeployment(DeploymentDescriptor dd) {
        deploys.add(dd);
        deployRegistry.add(dd);
        return deploymentMap.put(dd.getModuleName(), dd);
    }

    public List<DeploymentDescriptor> getAllDeployments() {
        Collections.sort(deploys);
        return deploys;
    }

    public void addInactiveDeployment(DeploymentDescriptor dd) {
        inactiveDeploys.add(dd);
    }

    public List<DeploymentDescriptor> getAllInactiveDeployments() {
        Collections.sort(inactiveDeploys);
        return inactiveDeploys;
    }

    public List<DeploymentDescriptor> getResolvedDeployments() {<FILL_FUNCTION_BODY>}

    public void addNoSpringPoweredDeployment(DeploymentDescriptor dd) {
        noSpringPoweredDeploys.add(dd.getModuleName());
    }

    public DeployRegistry getDeployRegistry() {
        return deployRegistry;
    }

    public DeploymentDescriptor getDeploymentByName(String moduleName) {
        return deploymentMap.get(moduleName);
    }

    public void addFailed(DeploymentDescriptor failed) {
        this.failed.add(failed);
    }

    public List<DeploymentDescriptor> getFailed() {
        return failed;
    }

    public void addInstalled(DeploymentDescriptor installed) {
        this.installed.add(installed);
    }

    public List<DeploymentDescriptor> getInstalled() {
        return installed;
    }

    public ModuleDeploymentValidator getModuleDeploymentValidator() {
        return moduleDeploymentValidator;
    }

    public void setModuleDeploymentValidator(ModuleDeploymentValidator moduleDeploymentValidator) {
        this.moduleDeploymentValidator = moduleDeploymentValidator;
    }

    public SofaModuleProfileChecker getSofaModuleProfileChecker() {
        return sofaModuleProfileChecker;
    }

    public void setSofaModuleProfileChecker(SofaModuleProfileChecker sofaModuleProfileChecker) {
        this.sofaModuleProfileChecker = sofaModuleProfileChecker;
    }

    @Override
    @NonNull
    public Map<String, ApplicationContext> getModuleApplicationContextMap() {
        Map<String, ApplicationContext> result = new HashMap<>(8);
        installed.forEach(deploymentDescriptor -> result.put(deploymentDescriptor.getModuleName(), deploymentDescriptor.getApplicationContext()));
        return result;
    }
}

        if (resolvedDeployments != null) {
            return resolvedDeployments;
        }

        //remove all required when no spring powered module exist
        deploymentMap.values().forEach(dd -> {
            List<String> requiredModules = dd.getRequiredModules();
            if (requiredModules != null) {
                // if required module is no spring powered, remove it
                requiredModules.removeIf(module -> !deploymentMap.containsKey(module) && noSpringPoweredDeploys.contains(module));
            }
        });

        resolvedDeployments = deployRegistry.getResolvedObjects();
        return resolvedDeployments;
    
<no_super_class>