Nloc.java

package nloc;

import java.util.List;
import java.util.ArrayList;
import java.util.ListIterator;
import java.util.Arrays;

public class Nloc {

  private static final int MIN_TIMEDIFF = 6;

  public static void main(String[] args) {

    List<Channel> chanlist = getNloc0();
    Channel p0 = chanlist.get(chanlist.size() - 2);

    List<Channel> mod = getModulesByName(Arrays.asList("m1","m2"), chanlist);

    List<List<Channel>> pathlist = getAllPaths(p0, new ArrayList<Channel>());
    printPaths(pathlist);

    List<Channel> desiredPath = getDesiredPath(mod, pathlist);

    System.out.println("Desired Path:");
    if (desiredPath.isEmpty()) {
      System.out.println("No such Path!");
    } else {
      printPath(desiredPath);
    }

    System.out.println("Number of Droplets needed: " + getNumberOfDroplets(desiredPath));




  }

  
  public static int getNumberOfDroplets(List<Channel> desiredPath) {
    int numOfDroplets = 1;
    ListIterator<Channel> iter = desiredPath.listIterator();
    while(iter.hasNext()) {
      Channel current = iter.next();
      if (current.isBifurcation()) {
        numOfDroplets *= (current.getChildrenList().indexOf(iter.next()) + 1);
        iter.previous();
      }
    }
    return numOfDroplets;
  }
  //public static List<Droplet> generateDropletSequence(List<Channel> path) {

  //}

  public static List<Channel> getDesiredPath(List<Channel> modules,
      List<List<Channel>> pathlist) {
    List<Channel> found = new ArrayList<Channel>();
    for (List<Channel> path : pathlist) {
      if (path.containsAll(modules)) {
        found = path;
      }
    }
    return found;
  }

  public static List<Channel> getModulesByName(List<String> names, 
      List<Channel> chanlist) {
    List<Channel> ret = new ArrayList<Channel>();
    for (String name : names) {
      for (Channel ch : chanlist) {
        if (ch instanceof Module && ((Module)ch).getModuleName().equals(name)) {
          ret.add(ch);
        } 
      }
    }
    return ret;
  }

  public static void printPath(List<Channel> path) {
    for (Channel ch : path) {
      System.out.print("ID: " + ch.getID() + " ");
    }
    System.out.println("");
  }

  public static void printPaths(List<List<Channel>> pathlist) {
    System.out.println("Number of paths found: " + pathlist.size());
    for (List<Channel> p : pathlist) {
      printPath(p);
    }
  }

  public static List<List<Channel>> getAllPaths(Channel chan, List<Channel> path) {
    List<List<Channel>> pl = new ArrayList<List<Channel>>();
    getAllPathsRecursive(chan, path, pl);
    return pl;
  }

  public static void getAllPathsRecursive(Channel chan, List<Channel> path, List<List<Channel>> pathlist) {
    path.add(chan);
    if (chan.getChildrenList().isEmpty()) { 
      pathlist.add(path);
    } else {
      for (Channel ch : chan.getChildrenList()) {
        getAllPathsRecursive(ch, new ArrayList<Channel>(path), pathlist);
      }
    }
  }

  public static List<Channel> getNloc0() {

    Channel chan0 = new Channel(6,6);
    Channel chan1 = new Channel(8,8);
    Channel chan2 = new Channel(9,9);
    Channel chan3 = new Channel(11,12);
    Channel chan4 = new Channel(19,21);
    Channel chan5 = new Channel(5,5);
    Channel chan6 = new Channel(8,8);
    Channel chan7 = new Channel(9,10);
    Channel chan8 = new Channel(25,28);

    Module m0 = new Module("m0", 22,10);
    Module m1 = new Module("m1", 10,10);

    Pump p0 = new Pump();
    Sink s0 = new Sink();

    List<Channel> chanlist = Arrays.asList(chan0, chan1, chan2, chan3, chan4,
        chan5, chan6, chan7, chan8, m0, m1, p0, s0);

    p0.addChild(chan0);
    chan0.addChild(chan1);
    chan1.addChild(chan2);
    chan1.addChild(chan3);
    chan2.addChild(chan4);
    chan3.addChild(chan5);
    chan5.addChild(m0);
    m0.addChild(chan6);
    chan4.addChild(chan7);
    chan6.addChild(chan7);
    chan7.addChild(m1);
    m1.addChild(chan8);
    chan8.addChild(s0);

    return chanlist;
  }

  public static List<Channel> getNloc3() {
    Channel chan0 = new Channel(6,6);
    Channel chan1 = new Channel(8,8);
    Channel chan2 = new Channel(9,9);
    Channel chan3 = new Channel(11,12);
    Channel chan4 = new Channel(19,21);
    Channel chan5 = new Channel(5,5);
    Channel chan6 = new Channel(8,8);
    Channel chan7 = new Channel(9,10);
    Channel chan8 = new Channel(25,28);
    Channel chan9 = new Channel(25,28);
    Channel chan10 = new Channel(25,28);

    Module m0 = new Module("m0", 22,10);
    Module m1 = new Module("m1", 10,10);
    Module m2 = new Module("m2", 22,10);
    Module m3 = new Module("m3", 10,10);

    Pump p0 = new Pump();
    Sink s0 = new Sink();

    List<Channel> chanlist = Arrays.asList(chan0, chan1, chan2, chan3, chan4,
        chan5, chan6, chan7, chan8, chan9, chan10, m0, m1, m2, m3, p0, s0);

    p0.addChild(chan0);
    chan0.addChild(chan1);
    chan0.addChild(chan2);
    chan1.addChild(m0);
    m0.addChild(chan3);
    chan3.addChild(chan5);
    chan2.addChild(m1);
    m1.addChild(chan4);
    chan4.addChild(chan5);
    chan5.addChild(chan6);
    chan5.addChild(chan7);
    chan6.addChild(m2);
    chan7.addChild(m3);
    m2.addChild(chan8);
    m3.addChild(chan9);
    chan8.addChild(chan10);
    chan9.addChild(chan10);
    chan10.addChild(s0);

    return chanlist;
  }
}