Application: gvSIG desktop

package org.gvsig.installer.lib.impl;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

import org.gvsig.installer.lib.api.Dependencies;

import org.gvsig.installer.lib.api.DependenciesCalculator;

import org.gvsig.installer.lib.api.Dependency;

import org.gvsig.installer.lib.api.PackageInfo;

import org.gvsig.installer.lib.api.Version;

import org.gvsig.installer.lib.api.execution.InstallPackageService;

public class DefaultDependenciesCalculator implements DependenciesCalculator {

        private InstallPackageService installService = null;

        private List<PackageInfo> packagesInstalleds = null;

        private List<PackageInfo> packagesToInstall = null;

    private List<PackageInfo> requieredPackages = null;

    private List<PackageInfo> conflictsPackages = null;

        private Dependencies unresolvedDependencies = null;

        public DefaultDependenciesCalculator(InstallPackageService installService) {

                super();

                this.installService = installService;

                this.packagesInstalleds = new ArrayList<PackageInfo>();

                this.packagesToInstall = new ArrayList<PackageInfo>();

        }

        private boolean addDependency(Dependencies dependencies, Dependency dependency) {

                try {

                        if( dependencies.contains(dependency) ) {

                                return false;

                        }

                        Dependency dep = (Dependency) dependency.clone();

                        dependencies.add(dep);

                } catch (CloneNotSupportedException e) {

                        throw new RuntimeException(e);

                }

                return true;

        }

        private void addDependency(Dependencies dependencies, PackageInfo packageInfo) {

                Dependencies pkgdependencies = packageInfo.getDependencies();

                if( pkgdependencies != null ) {

                        Iterator<Dependency> it = pkgdependencies.iterator();

                        while( it.hasNext() ) {

                                this.addDependency(dependencies, it.next());

                        }

                }

        }

        public void addPackageToInstall(PackageInfo packageInfo) {

                this.packagesToInstall.add(packageInfo);

        }

        public void addPackageToInstall(Collection<PackageInfo> packages) {

                Iterator<PackageInfo> it = packages.iterator();

                while(it.hasNext()) {

                        this.addPackageToInstall(it.next());

                }

        }

        public void addInstalledPackage(PackageInfo packageInfo) {

                this.packagesInstalleds.add(packageInfo);

        }

        public void addInstalledPackage(PackageInfo[] packages) {

                for(int i=0; i<packages.length; i++) {

                        this.addInstalledPackage(packages[i]);

                }

        }

        public void calculate() {

                // Inicializa el conjunto de paquetes ya instalados mas los que 

                // se han solicitado instalar.

                List<PackageInfo> packages = new ArrayList<PackageInfo>();

                packages.addAll(this.packagesInstalleds);

                packages.addAll(this.packagesToInstall);

                List<PackageInfo> requieredPackages;

                for( int retries=0; retries<100; retries++) {

                        requieredPackages = new ArrayList<PackageInfo>();

                        System.out.println("Pass "+ retries);

                        System.out.println("All packages (installed+to-install):");

                        System.out.println(dumpPackages(packages));

                        Dependencies dependencies = new DefaultDependencies();

                        Iterator<PackageInfo> it = packages.iterator();

                        while( it.hasNext() ) {

                                this.addDependency(dependencies, it.next());

                        }

                        System.out.println("Dependencies:");

                        System.out.println(dumpDependencies(dependencies));

                        unresolvedDependencies  = new DefaultDependencies();

                        unresolvedDependencies.addAll(dependencies);

                        for( int i=0; i<this.installService.getPackageCount(); i++ ) {

                                PackageInfo pkg = this.installService.getPackageInfo(i);

                                System.out.print("Check ");

                                System.out.println(pkg.toStringCompact());

                                Dependency foundDependency = dependencies.find(Dependency.REQUIRED, pkg.getCode(), pkg.getVersion());

                                if( foundDependency != null) {

                                        PackageInfo pkg1 = getByCodeAndVersion(packages, pkg.getCode(),pkg.getVersion());

                                        if( pkg1 == null ) {

                                                System.out.println("           Add required");

                                                requieredPackages.add(pkg);

                                        } 

                                        unresolvedDependencies.remove(foundDependency);

                                }

                if( dependencies.match(Dependency.CONFLICT, pkg.getCode(), pkg.getVersion())) {

                    PackageInfo pkg1 = getByCodeAndVersion(packages, pkg.getCode(),pkg.getVersion());

                    if( pkg1 == null ) {

                        System.out.println("           Add conflicts");

                        conflictsPackages.add(pkg);

                    } 

                }

//                if( dependencies.match(Dependency.RECOMMENDED, pkg.getCode(), pkg.getVersion())) {

//                    PackageInfo pkg1 = getByCodeAndVersion(packages, pkg.getCode(),pkg.getVersion());

//                    if( pkg1 == null ) {

//                        System.out.println("           Add conflicts");

//                        conflictsPackages.add(pkg);

//                    } 

//                }

                        }

                        System.out.println("required packages:");

                        System.out.println(dumpPackages(requieredPackages));

                        if( requieredPackages.size() == 0 ) {

                                break;

                        }

                        packages.addAll(requieredPackages);

                        removeDuplicateds(packages);

                }

                // Eliminamos de la lista de paquetes los que ya estan instalados o

                // los que elusuario pidio instalar.

                requieredPackages = new ArrayList<PackageInfo>();

                Iterator<PackageInfo> it = packages.iterator();

                while( it.hasNext() ) {

                        PackageInfo pkg = it.next();

                        if( this.packagesInstalleds.contains(pkg) ) {

                                continue;

                        }

                        if( this.packagesToInstall.contains(pkg) ) {

                                continue;

                        }

                        requieredPackages.add(pkg);

                }

                Collections.sort(requieredPackages, new Comparator<PackageInfo>() {

                        public int compare(PackageInfo o1, PackageInfo o2) {

                                return o1.getName().compareTo(o2.getName());

                        }

                });

                System.out.println("required packages");

                System.out.println(dumpPackages(requieredPackages));

                this.requieredPackages = requieredPackages;

        }

    public List<PackageInfo> getRequiredPackages() {

        return this.requieredPackages;

    }

    public List<PackageInfo> getConflictPackages() {

        return this.conflictsPackages;

    }

    public Dependencies getUnresolvedDependencies() {

        return this.unresolvedDependencies;

    }

        private PackageInfo getByCodeAndVersion(Collection<PackageInfo> packages, String code, Version version) {

                Iterator<PackageInfo> it1 = packages.iterator();

                while( it1.hasNext() ) {

                        PackageInfo pkg1 = it1.next();

                        if( pkg1.getCode().equalsIgnoreCase(code) ) {

                                if( pkg1.getVersion().check(">=", version)) {

                                        return pkg1;

                                }

                        }

                }

                return null;

        }

        private void removeDuplicateds(List<PackageInfo> packages) {

                boolean copy;

                List<PackageInfo> lpackages = new ArrayList<PackageInfo>();

                Iterator<PackageInfo> it1 = packages.iterator();

                while( it1.hasNext() ) {

                        PackageInfo pkg1 = it1.next();

                        copy = true;

                        Iterator<PackageInfo> it2 = packages.iterator();

                        while( it2.hasNext() ) {

                                PackageInfo pkg2 = it2.next();

                                if( pkg1 == pkg2 ) {

                                        continue;

                                }

                                if( !pkg1.getCode().equalsIgnoreCase(pkg2.getCode())) {

                                        continue;

                                }

                                if( pkg2.getVersion().check("<", pkg1.getVersion())) {

                                        continue;

                                }

                                copy = false;

                                break;

                        }

                        if( copy ) {

                                lpackages.add(pkg1);

                        } 

                }

                packages.clear();

                packages.addAll(lpackages);

        }

        private String dumpPackages(Collection<PackageInfo> pkgs) {

                StringBuffer s = new StringBuffer();

                Iterator<PackageInfo> it = pkgs.iterator();

                while( it.hasNext() ) {

                        s.append(it.next().toStringCompact());

                        s.append("\n");

                }

                return s.toString();

        }

        private String dumpDependencies(Collection<Dependency> dependencies) {

                StringBuffer s = new StringBuffer();

                Iterator<Dependency> it = dependencies.iterator();

                while( it.hasNext() ) {

                        s.append(it.next().toString());

                        s.append("\n");

                }

                return s.toString();

        }

}