packagemanager.java

package sfdctest;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.TreeMap;
import java.util.HashSet;
import java.util.Map;
import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class PackageManager {

    private Map<String, Package> system;
    private Map<String, Package> installed;
    public static enum Actions {
        DEPEND,
        INSTALL,
        REMOVE,
        LIST,
        END
    }

    private class Package{
        private String name;
        private Set<Package> dependencies;
        private Set<Package> dependents;
        private boolean isActive;
        private boolean firstClass;

        public Package(String name){
            this.name  = name;
            this.dependencies = new HashSet<Package>();
            this.dependents = new HashSet<Package>();
            this.isActive = false;
            this.firstClass = false;
        }

        public boolean addDependency(Package p){
            if (this.isActive){
                System.out.println("\tCannot add dependency to installed package. Uninstall first");
                return false;
            }
            if (!this.hasCircularDependencyOn(p)){
                this.dependencies.add(p);
                //p.addDependent(this);
                return true;
            } else {
                System.out.println("\t" + this.getName() + " depends on " + p.getName() + ". Ignoring command.");
                return false;
            }
        }

        public boolean hasCircularDependencyOn(Package p){
            LinkedList<Package> remaining = new LinkedList<Package>();
            remaining.add(p);
            List<Package> visited = new ArrayList<Package>();
            while(!remaining.isEmpty()){
                Package dependent = remaining.removeFirst();
                if (dependent.equals(this)){
                    return true;
                } else {
                    visited.add(dependent);
                    for (Package c: dependent.dependencies()){
                        if (!visited.contains(c)){
                            remaining.addLast(c);
                        }
                    }
                }
            }
            return false;
        }

        public void addDependent(Package p){
            this.dependents.add(p);
        }


        public void removeDependent(Package p){
            this.dependents.remove(p);
            if (this.dependents.size() == 0 && !this.firstClass){
                uninstall();
            }
        }

        @Override
        public String toString(){
            return this.name;
        }

        public String getName(){
            return this.name;
        }

        public Set<Package> dependencies(){
            return this.dependencies;
        }

        //installs as a primary package meaning it uses itself and is
        //not simply a dependency
        public void installPrimary(){
            if (!this.install()){
                System.out.println("\t" + this.getName() + " already installed.");
            };
            this.firstClass = true;
        }

        public boolean install(){
            if (this.isActive){
                return false;
            }
            for (Package dependency: this.dependencies){
                if (!installed.containsKey(dependency.getName())){
                    dependency.install();
                }
                //Let this package know its is being used by us
                dependency.addDependent(this);
            }
            installed.put(this.name, this);
            this.isActive = true;
            System.out.println("\tInstalling " + this.name);
            return true;
        }


        public void uninstallPrimary(){
            if(!this.uninstall()){
                System.out.println("\t"+ this.name + " is still needed");
            }
            this.firstClass = false;
        }

        public boolean uninstall(){
            if (this.dependents.size() > 0){
                return false;
            }

            installed.remove(this.getName());

            this.isActive = false;

            for(Package using: this.dependencies){
                using.removeDependent(this);
            }

            System.out.println("\tRemoving " + this.getName());
            return true;
        }
    }

    public PackageManager(){
        this.system = new HashMap<String, Package>();
        this.installed = new TreeMap<String, Package>();
    }


    public Package createPackage(String package_name){
        this.system.put(package_name, new Package(package_name));
        return getPackage(package_name);
    }

    public Package getPackage(String package_name){
        return this.system.get(package_name);
    }

    public void createDependencies(String[] packages){
        for (int i = 1; i < packages.length; i++){
            if(!this.system.containsKey(packages[i])){
                createPackage(packages[i]);
            }
        }
        Package primary = this.system.get(packages[1]);
        for (int i = 2; i < packages.length; i++){
            primary.addDependency(getPackage(packages[i]));
        }
    }
    public void installPackage(String package_name){
        Package p;
        if (!this.system.containsKey(package_name)){
            p = createPackage(package_name);
        } else {
            p = getPackage(package_name);
        }
        p.installPrimary();
    }

    public void listPackages(){
        for(String name: this.installed.keySet()){
            System.out.println("\t"+name);
        }
    }


    public Map<String, Package> getInstalledPackages(){
        return this.installed;
    }

    public Map<String, Package> getSystemPackages(){
        return this.system;
    }
    public void uninstallPackage(String package_name){
        if (this.installed.containsKey(package_name)){
            Package p = getPackage(package_name);
            p.uninstallPrimary();
        } else {
            System.out.println("\t" + package_name + " is not installed");
        }

    }

    public static void main(String[] args){

        PackageManager aptGet = new PackageManager();
        File instructions = new File("/Users/timi/src/study/Study/src/sftestprep/datax.txt");
        Scanner scanner = null;
        try {
            scanner = new Scanner(instructions);
            while (scanner.hasNextLine()){
                String line = scanner.nextLine();
                //Echo the line
                System.out.println(line);
                String[] tokens = line.split("\\s+");
                String command = tokens[0];
                switch(PackageManager.Actions.valueOf(command)) {

                    case DEPEND:
                        aptGet.createDependencies(tokens);
                        break;
                    case INSTALL:
                        aptGet.installPackage(tokens[1]);
                        break;
                    case REMOVE:
                        aptGet.uninstallPackage(tokens[1]);
                        break;
                    case LIST:
                        aptGet.listPackages();
                        break;
                    case END:
                        //We want to exit the while loop on this
                        return;
                    default:
                        break;
                }
            }
        } catch(FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            scanner.close();
        }
    }
}