public List reorderModules()

in plugins/org.apache.geronimo.st.v21.core/src/main/java/org/apache/geronimo/st/v21/core/internal/DependencyHelper.java [84:235]
113 lines of code
29 McCabe index (conditional complexity)

    public List reorderModules(IServer server, List modules, List deltaKind ) {
        Trace.tracePoint("Entry", Activator.traceInternal, "DependencyHelper.reorderModules", modules, deltaKind);
        
        //provide a cache
        ConcurrentHashMap<String,Boolean> verifiedModules = new ConcurrentHashMap<String,Boolean>();


        if (modules.size() == 0) {
            List reorderedLists = new ArrayList(2);
            reorderedLists.add(modules);
            reorderedLists.add(deltaKind);
            Trace.tracePoint("Exit ", Activator.traceInternal, "DependencyHelper.reorderModules", reorderedLists);
            return reorderedLists;
        }

        inputModules = modules;
        inputDeltaKind = deltaKind;

        // 
        // Iterate through all the modules and register the dependencies
        // 
        for (int ii=0; ii<modules.size(); ii++) {
            IModule[] module = (IModule[]) modules.get(ii);
            int moduleDeltaKind = ((Integer)deltaKind.get(ii)).intValue();
            if (moduleDeltaKind != ServerBehaviourDelegate.REMOVED) {
            	//GERONIMODEVTOOLS-361
            	for (IModule singleModule:module){
            		Environment environment = getEnvironment(singleModule);
	                if (environment != null) {
	                    Artifact child = environment.getModuleId();
	                    Dependencies dependencies = environment.getDependencies();
	                    if (dependencies != null) {
	                        List<Dependency> depList = dependencies.getDependency();
	                        for ( Dependency dep : depList) {
	                            Artifact parent = deploymentFactory.createArtifact();
	                            parent.setGroupId( dep.getGroupId() );
	                            parent.setArtifactId( dep.getArtifactId() );
	                            parent.setVersion( dep.getVersion() );
	                            parent.setType( dep.getType() );
	                            
	                            StringBuilder configId = new StringBuilder();
	                            if (dep.getGroupId()!=null)
	                            	configId.append(dep.getGroupId());
	                            configId.append("/");
	                            if (dep.getArtifactId()!=null)
	                            	configId.append(dep.getArtifactId());
	                            configId.append("/");
	                            if (dep.getVersion()!=null)
	                            	configId.append(dep.getVersion());
	                            configId.append("/");
	                            if (dep.getType()!=null)
	                            	configId.append(dep.getType());
	                            
	                            //get install flag from the cache
								Boolean isInstalledModule = verifiedModules
										.get(configId.toString());
								if (isInstalledModule == null) {
									// not in the cache, invoke
									// isInstalledModule() method
									isInstalledModule = DeploymentUtils
											.isInstalledModule(server,
													configId.toString());
									// put install flag into the cache for next
									// retrieve
									verifiedModules.put(configId.toString(),
											isInstalledModule);
								}

								if (!isInstalledModule)
                                    dm.addDependency( child, parent );
	                        }
	                    }
	                }
            	}
            }
        }

        // 
        // Iterate through all the modules again and reorder as necessary
        // 
        for (int ii=0; ii<modules.size(); ii++) {
            IModule[] module = (IModule[]) modules.get(ii);
            int moduleDeltaKind = ((Integer)deltaKind.get(ii)).intValue();
            if (module!=null && !reorderedModules.contains(module)) {
                // Not already moved 
                if (moduleDeltaKind == ServerBehaviourDelegate.REMOVED) {
                    // Move module if going to be removed 
                    reorderedModules.add(module);
                    reorderedKinds.add(moduleDeltaKind);
                }
                else {
                    Environment environment = getEnvironment(module[0]);
                    if (environment != null) {
                        Artifact artifact = environment.getModuleId();
                        if (artifact == null) {
                            // Move if null (nothing can be done)
                            if (!reorderedModules.contains(module)) {
                                reorderedModules.add(module);
                                reorderedKinds.add(moduleDeltaKind);
                            }
                        }
                        else if (dm.getParents(artifact).contains(artifact) ||  
                                 dm.getChildren(artifact).contains(artifact)) {
                            // Move if a tight circular dependency (nothing can be done)
                            if (!reorderedModules.contains(module)) {
                                reorderedModules.add(module);
                                reorderedKinds.add(moduleDeltaKind);
                            }
                        }
                        else if (dm.getParents(artifact).size() == 0) {
                            // Move if no parents (nothing to do)
                            if (!reorderedModules.contains(module)) {
                                reorderedModules.add(module);
                                reorderedKinds.add(moduleDeltaKind);
                            }
                        }
                        else if (dm.getParents(artifact).size() > 0) {
                            // Move parents first
                            processParents(dm.getParents(artifact), artifact);
                            // Move self 
                            if (!reorderedModules.contains(module)) {
                                reorderedModules.add(module);
                                reorderedKinds.add(moduleDeltaKind);
                            }
                        }
                    }else {
                    	//no environment defined, do just as no parents
                        if (!reorderedModules.contains(module)) {
                            reorderedModules.add(module);
                            reorderedKinds.add(moduleDeltaKind);
                        }
                    }
                }
            }
        }

        // 
        // Ensure return lists are exactly the same size as the input lists 
        // 
        assert reorderedModules.size() == modules.size();
        assert reorderedKinds.size() == deltaKind.size();

        // 
        // Return List of lists
        // 
        List reorderedLists = new ArrayList(2);
        reorderedLists.add(reorderedModules);
        reorderedLists.add(reorderedKinds);

        Trace.tracePoint("Exit ", Activator.traceInternal, "DependencyHelper.reorderModules", reorderedLists);
        return reorderedLists;
    }