Add semantic zooming based on phylogenetic

code.java

@@ -0,0 +1,8 @@
+
+    public static void main(String[] args) {
+        TokenIterator it = new TokenIterator("cbbaaacabaa", "bc");
+        while (it.hasNext()) {
+            System.out.println("next: " + it.next());
+        }
+    }
+

src/main/java/io/github/programminglife2016/pl1_2016/parser/BaseTreeNode.java

@@ -2,6 +2,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import static java.util.stream.Collectors.*;
 
 /**
  * Class for representing a node in the phylogenetic tree.
@@ -104,6 +105,9 @@ public List<TreeNode> getChildren() {
      */
     @Override
     public String toString() {
-        return String.format("BaseTreeNode{id= %d, weight= %d, children= %d, parent = %d}", id, weight, children, parent);
+        return "[" + this.getId() + " " + this.getWeight()
+                + " {" + children.stream()
+                                 .map(Object::toString)
+                                 .collect(joining(", ")) + "}]";
     }
 }

src/main/java/io/github/programminglife2016/pl1_2016/parser/PhyloGeneticTreeParser.java

@@ -1,10 +1,11 @@
 package io.github.programminglife2016.pl1_2016.parser;
 
+import io.github.programminglife2016.pl1_2016.Launcher;
+
+import java.io.ByteArrayInputStream;
 import java.io.InputStream;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Scanner;
-import java.util.StringTokenizer;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
 
 
 /**
@@ -15,9 +16,7 @@ public class PhyloGeneticTreeParser implements Parser {
     @Override
     public JsonSerializable parse(InputStream inputStream) {
         String s = inputStreamToString(inputStream);
-        StringTokenizer tokenizer = new StringTokenizer(s, "(:,);", true);
-        TreeNode root = constructTree(null, tokenizer);
-        root = root.getChildren().get(0);
+        TreeNode root = parseTokensFromString(s);
         return null;
     }
 
@@ -28,50 +27,78 @@ private String inputStreamToString(InputStream inputStream) {
         return s;
     }
 
+    /**
+     * Create tree from string.
+     * @param s string representin the tree.
+     * @return root of tree
+     */
+    public TreeNode parseTokensFromString(String s) {
+        StringIterator tokenizer = new TokenIterator(s, "(:,);", true);
+        TreeNode root = constructTree(null, tokenizer);
+        return root.getChildren().get(0);
+    }
+
     /**
      * Construct tree from the input of the String Tokenizer.
      * @param parent parent of the current node.
      * @param tokenizer tokenizer with the contents of the .nwk file.
      * @return parsed Tree Node object.
      */
-    public TreeNode constructTree(TreeNode parent, StringTokenizer tokenizer) {
+    public TreeNode constructTree(TreeNode parent, StringIterator tokenizer) {
         TreeNode current = new BaseTreeNode();
         String next;
         double weight;
         List<TreeNode> nodes = new ArrayList<>();
-        while (tokenizer.hasMoreElements()) {
-            next = tokenizer.nextToken();
+        while (tokenizer.hasNext()) {
+            next = tokenizer.next();
             switch (next) {
-                case "(":
-                    TreeNode newNode = constructTree(current, tokenizer);
-                    nodes.add(newNode);
-                    if (tokenizer.hasMoreTokens()) {
-                        tokenizer.nextToken();
-                    }
-                    break;
-                case ":":
-                    current.setWeight(Double.parseDouble(tokenizer.nextToken()));
-                    break;
-                case ",":
-                    nodes.add(current);
-                    current = new BaseTreeNode();
-                    break;
-                case ")":
+            case "(":
+                TreeNode newNode = constructTree(current, tokenizer);
+                nodes.add(newNode);
+                if (tokenizer.hasNext()) {
+                    tokenizer.next();
+                }
+                break;
+            case ":":
+                current.setWeight(Double.parseDouble(tokenizer.next()));
+                break;
+            case ",":
+                nodes.add(current);
+                current = new BaseTreeNode();
+                break;
+            case ")":
+                if (!current.getId().equals("-") && current.getWeight() != 0.0) {
                     nodes.add(current);
-                    weight = 0;
-                    if (tokenizer.hasMoreTokens() && tokenizer.nextToken().equals(":")) {
-                        weight = Double.parseDouble(tokenizer.nextToken());
-                    }
-                    return new BaseTreeNode("-", weight, nodes, parent);
-                case ";":
-                    current.setChildren(nodes);
-                    return current;
-                default:
-                    current.setId(next);
-                    break;
+                }
+                weight = 0;
+                if (tokenizer.hasNext() && tokenizer.next().equals(":")) {
+                    weight = Double.parseDouble(tokenizer.next());
+                }
+                return new BaseTreeNode("-", weight, nodes, parent);
+            case ";":
+                current.setChildren(nodes);
+                return current;
+            default:
+                current.setId(next);
+                break;
             }
         }
         current.setChildren(nodes);
         return current;
     }
+
+    /**
+     * Test parser.
+     * @param args args.
+     */
+    public static void main(String[] args) {
+        System.out.println("PhylgoGenetic Tree Parser");
+        PhyloGeneticTreeParser parser = new PhyloGeneticTreeParser();
+//        String s = "(A: 0.1,B: 0.2,(C:0.3,D:0.4):0.5);";
+        String s = "(A: 0.1,B: 0.2,(C:0.3,(Z:1,Y:2):0.4):0.5);";
+//        parser.parse(Launcher.class.getResourceAsStream("/genomes/340tree.rooted.TKK.nwk"));
+        s = "(A:0.1,(B:0.2,(C:0.3,(D:0.4,E:0.5):0.6):0.4):0.5);";
+        System.out.println("Done");
+        parser.parse(new ByteArrayInputStream(s.getBytes(StandardCharsets.UTF_8)));
+    }
 }

src/main/java/io/github/programminglife2016/pl1_2016/parser/StringIterator.java

@@ -0,0 +1,11 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import java.util.Iterator;
+
+public interface StringIterator extends Iterator<String> {
+    /**
+     * Get the next string from the iterator.
+     * @return next string.
+     */
+    String peek();
+}

src/main/java/io/github/programminglife2016/pl1_2016/parser/StringTokenizerAdapter.java

@@ -0,0 +1,46 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import java.util.Iterator;
+import java.util.StringTokenizer;
+import java.util.function.Consumer;
+
+/**
+ * Adapter for the StringTokenizer class.
+ */
+public class StringTokenizerAdapter extends StringTokenizer implements StringIterator {
+
+    /**
+     * Create StringTokinzerAdapter object.
+     * @param str string to split up into tokens.
+     * @param delim delimters of the tokens.
+     * @param returnDelims if the tokenizer should return the delimiters itself.
+     */
+    public StringTokenizerAdapter(String str, String delim, boolean returnDelims) {
+        super(str, delim, returnDelims);
+    }
+
+    @Override
+    public void remove() {
+
+    }
+
+    @Override
+    public void forEachRemaining(Consumer<? super String> action) {
+
+    }
+
+    @Override
+    public boolean hasNext() {
+        return this.hasMoreTokens();
+    }
+
+    @Override
+    public String next() {
+        return this.nextToken();
+    }
+
+    @Override
+    public String peek() {
+        return null;
+    }
+}

src/main/java/io/github/programminglife2016/pl1_2016/parser/TokenIterator.java

@@ -0,0 +1,66 @@
+package io.github.programminglife2016.pl1_2016.parser;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+import java.util.stream.Collector;
+
+public class TokenIterator implements StringIterator {
+    private String tokens;
+    private int pos;
+    private String delimiters;
+    private StringBuilder sb;
+
+    public TokenIterator(String tokens, String delimiters, boolean r) {
+        this.delimiters = delimiters;
+        this.tokens = tokens;
+        reset();
+    }
+
+    public void reset() {
+        this.pos = 0;
+    }
+
+    public String peek() {
+        if (hasNext()) {
+            int tempPos = this.pos;
+            String next = this.next();
+            this.pos = tempPos;
+            return next;
+        } else {
+            return "";
+        }
+    }
+
+    @Override
+    public boolean hasNext() {
+        return (pos < tokens.length());
+    }
+
+    @Override
+    public String next() {
+        sb = new StringBuilder();
+        char c = tokens.charAt(pos);
+        while (hasNext() && delimiters.indexOf(c) == -1) {
+            sb.append(c);
+            pos++;
+            if (hasNext()) {
+                c = tokens.charAt(pos);
+            }
+        }
+        if (sb.length() == 0) {
+            sb.append(c);
+            pos++;
+        }
+        return sb.toString();
+    }
+
+    @Override
+    public void remove() {
+
+    }
+
+    @Override
+    public void forEachRemaining(Consumer<? super String> action) {
+
+    }
+}