grad auf halbem weg zur generiertung der moeglichen sequenzen an einer bifurcation

src/Droplet.java

@@ -15,6 +15,12 @@ public class Droplet {
     this.position.getChannel().addDroplet(this);
   }
 
+  public Droplet(DropletType type) {
+    this.position = null;
+    this.type = type;
+    this.pumpOutlet = null;
+  }
+
   public void move() {
     position.increment(this);
   }
@@ -101,7 +107,9 @@ public class Droplet {
   }
 
   public void setPosition(Position position) {
-    this.position.getChannel().removeDroplet(this);
+    if (position != null) {
+      this.position.getChannel().removeDroplet(this);
+    }
     this.position = position;
     this.position.getChannel().addDroplet(this);
   }

src/Nloc.java

@@ -67,23 +67,16 @@ public class Nloc {
     }
   }
 
-  public List<BFTableEntry> initializeBifTable(List<Channel> desiredPath) {
+  public List<Channel> getBifurcationList(List<Channel> desiredPath) {
 
-    List<BFTableEntry> bftable = new ArrayList<BFTableEntry>();
-    
-    ListIterator<Channel> iter = desiredPath.listIterator();
-
-    while(iter.hasNext()) {
-      Channel current = iter.next();
-      if (current.isBifurcation()) {
-        Channel following = iter.next();
-        int prio = current.getChildrenList().indexOf(following) + 1;
-        int bfMinSteps = current.getChildrenList().get(0).getHSteps();
-        bftable.add(new BFTableEntry(prio, bfMinSteps));
-        iter.previous();
+    List<Channel> bfList = new ArrayList<Channel>();
+
+    for (Channel ch: desiredPath) {
+      if (ch.isBifurcation) {
+        bfList.add(ch);
       }
-    } 
-    return bftable;
+    }
+    return bfList;
   }
     
   //public Pump generateDropletSequence(List<String> modules) 
@@ -95,8 +88,8 @@ public class Nloc {
   //  List<List<Channel>> pathlist = this.getAllPaths();
   //  List<Channel> desiredPath = getDesiredPath(modPath, pathlist);
 
-  //  List<BFTableEntry> bftable = calcBFTable(desiredPath);
-  //  BFTableEntry startConfiguration = bftable.get(0);
+  //  List<SequenceTuple> bftable = calcBFTable(desiredPath);
+  //  SequenceTuple startConfiguration = bftable.get(0);
 
   //  pump = createDropletsequenceInPump(pump, startConfiguration);
 
@@ -104,7 +97,7 @@ public class Nloc {
   //}
 
   //private Pump createDropletsequenceInPump(Pump pump, 
-  //    BFTableEntry startConfiguration) {
+  //    SequenceTuple startConfiguration) {
   //  int noOfDroplets = startConfiguration.getNoOfDroplets();
   //  int minTimediff = startConfiguration.getMinTimediff();
 
@@ -220,20 +213,55 @@ public class Nloc {
     }
   }
 
-  public List<List<Channel>> getSequencesAtBifurcation(
-      List<Channel> path, Channel currentChan) {
+  public List<List<SequenceTuple>> getSequencesAtBifurcation(
+      List<SequenceTuple> seqTup, SequenceTuple currentSeqTup, 
+      Channel currentBifurcation) {
+
 
+    List<List<SequenceTuple>> seqTupList = new ArrayList<List<SequenceTuple>>();
 
-    List<List<Channel>> chanList = new ArrayList<List<Channel>>();
-    getSequencesAtBifurcationRecursive(path, currentChan, chanList);
-    return chanList;
+    getSequencesAtBifurcationRecursive(seqTup, currentSeqTup, seqTupList,
+        currentBifurcation);
+
+    return seqTupList;
   }
 
   private void getSequencesAtBifurcationRecursive(
-      List<Channel> path, Channel currentChan, 
-      List<List<Channel>> possibleSequences) {
+      List<SequenceTuple> seqTupList, SequenceTuple currentSeqTup, 
+      List<List<SequenceTuple>> possibleSequences, Channel currentBifurcation) {
+
+    if (currentSeqTup.equals(seqTupList.get(seqTupList.size() - 1))) {
+
+      // if at last sequence tuple add another header droplet tuple if needed
+      // and add the list of sequence tuples to the possible sequences list
+
+      // check if header droplet is needed
+      List<Channel> dropletPath = currentSeqTup.getPath();
+      Channel bifurcSuccessor  = 
+        dropletPath.get(dropletPath.indexOf(currentBifurcation) + 1);
+
+      // bifurcation priority: prio = 0 if default channel; prio >= 1 if not 
+      // default and threrfore header droplet needed
+      int prio = currentBifurcation.getChildrenList().indexOf(bifurcSuccessor);
+
+      if (dropletPath.contains(currentBifurcation) && prio > 0) {
+        // we need header droplet 
+        
+        // cirst check all possible paths of heder droplets
+        List<List<Channel>> pathList = 
+          this.getAllPathsFromTo(dropletPath.get(0), 
+              currentBifurcation.getChildrenList().get(0));
+        
+        for (List<Channel> path: pathList) {
+          List<SequenceTuple> tmp = new ArrayList<SequenceTuple>(seqTupList);
+          tmp.add(new SequenceTuple(new Droplet(DropletType.HEADER),path));
+
+          // TODO: berechnen und setzen von den pump offsets
+
+          possibleSequences.add(tmp);
+        }
+      }
 
-    if (currentChan.equals(path.get(path.size() - 1))) {
 
     } else {
 

src/BFTableEntry.java → src/SequenceTuple.java

 package nloc;
 
-public class BFTableEntry {
+public class SequenceTuple {
   
   private Droplet droplet;
   private int minPos, maxPos;
   private List<Channel> path;
 
-  public BFTableEntry(Droplet droplet, List<Channel> path) {
+  public SequenceTuple(Droplet droplet, List<Channel> path) {
     this.minPos = 0;
     this.maxPos = 0;
     this.droplet = droplet;