Merge pull request #47 from rutgervandenberg/dev

Implement Sequence class and controller for filtering in views. All looks good, can be merged.

Author: joswinter

pom.xml

@@ -17,6 +17,12 @@
       <version>4.12</version>
       <scope>test</scope>
     </dependency>
+    <dependency>
+      <groupId>org.mockito</groupId>
+      <artifactId>mockito-all</artifactId>
+      <version>1.9.5</version>
+      <scope>test</scope>
+    </dependency>
     <dependency>
       <groupId>org.jgrapht</groupId>
       <artifactId>jgrapht-core</artifactId>

src/main/java/nl/tudelft/lifetiles/controller/ViewController.java

@@ -0,0 +1,68 @@
+package nl.tudelft.lifetiles.controller;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Observable;
+import java.util.Set;
+
+import nl.tudelft.lifetiles.graph.Sequence;
+
+/**
+ * @author Rutger van den Berg
+ *         Controls what the view modules display.
+ */
+public class ViewController extends Observable {
+    /**
+     * Map of all sequences currently loaded.
+     */
+    private Map<String, Sequence> sequenceMap;
+    /**
+     * Set containing all sequences currently loaded.
+     */
+    private Set<Sequence> allSequences;
+    /**
+     * Set containing the currently visible sequences.
+     */
+    private Set<Sequence> visibleSequences;
+
+    /**
+     * Creates a new viewcontroller.
+     *
+     * @param sequences
+     *            The current sequences.
+     */
+    public ViewController(final Map<String, Sequence> sequences) {
+        sequenceMap = sequences;
+        allSequences = new HashSet<>();
+
+        for (Map.Entry<String, Sequence> map : sequenceMap.entrySet()) {
+            Sequence seq = map.getValue();
+            allSequences.add(seq);
+        }
+        visibleSequences = new HashSet<>(allSequences);
+    }
+
+    /**
+     * Sets the visible sequences in all views to the provided sequences.
+     *
+     * @param sequences
+     *            The sequences to set to visible.
+     */
+    public final void setVisible(final Set<Sequence> sequences) {
+        visibleSequences = sequences;
+        if (visibleSequences.retainAll(allSequences)) {
+            throw new IllegalArgumentException(
+                    "Attempted to set a non-existant sequence to visible");
+        }
+        setChanged();
+        notifyObservers();
+    }
+
+    /**
+     * @return A set containing all visible sequences.
+     */
+    public final Set<Sequence> getVisible() {
+        return visibleSequences;
+    }
+
+}

src/main/java/nl/tudelft/lifetiles/graph/DefaultGraphParser.java

@@ -4,9 +4,10 @@
 import java.io.IOException;
 import java.net.URISyntaxException;
 import java.nio.file.Files;
-import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.Map;
 import java.util.Set;
 
 /**
@@ -73,12 +74,13 @@ private void parseEdges(final String filename,
      */
     private void parseVertices(final String filename,
             final Graph<SequenceSegment> graph) {
+        Map<String, Sequence> sequences = new HashMap<>();
         try {
             File file = new File(this.getClass()
                     .getResource("/" + filename + ".node.graph").toURI());
             Iterator<String> it = Files.lines(file.toPath()).iterator();
             while (it.hasNext()) {
-                graph.addVertex(createSegment(it.next(), it.next()));
+                graph.addVertex(createSegment(it.next(), it.next(), sequences));
             }
         } catch (IOException e) {
             e.printStackTrace();
@@ -92,22 +94,28 @@ private void parseVertices(final String filename,
      *            Description line in the vertex file.
      * @param content
      *            Content line in the vertex file.
+     * @param sequences
+     *            A map containing sequences that have already been seen.
      * @return a new SequenceSegment
      */
     private SequenceSegment createSegment(final String descriptor,
-            final String content) {
+            final String content, final Map<String, Sequence> sequences) {
         if (!descriptor.startsWith(">")) {
             throw new IllegalArgumentException();
         }
         String[] desc = descriptor.split("\\|");
         String[] sources = desc[2].split(",");
-        for (String s : sources) {
-            s = s.trim();
+        Set<Sequence> currentSequences = new HashSet<>();
+        for (String sequencename : sources) {
+            if (!sequences.containsKey(sequencename.trim())) {
+                sequences.put(sequencename, new SequenceImplementation(
+                        sequencename));
+            }
+            currentSequences.add(sequences.get(sequencename));
         }
-        Set<String> s = new HashSet<String>();
-        Collections.addAll(s, sources);
 
-        return new SequenceSegment(s, Integer.parseInt(desc[START_POS].trim()),
+        return new SequenceSegment(currentSequences,
+                Integer.parseInt(desc[START_POS].trim()),
                 Integer.parseInt(desc[END_POS].trim()), content.trim());
 
     }

src/main/java/nl/tudelft/lifetiles/graph/Sequence.java

@@ -0,0 +1,29 @@
+package nl.tudelft.lifetiles.graph;
+
+import java.util.List;
+
+/**
+ * @author Rutger van den Berg
+ *         Interface for complete sequences.
+ */
+public interface Sequence {
+    /**
+     * Return the segments related to this sequence.
+     *
+     * @return A list of sequence segments.
+     */
+    List<SequenceSegment> getSegments();
+
+    /**
+     * Add a segment to the sequence.
+     *
+     * @param segment
+     *            The segment to append.
+     */
+    void appendSegment(SequenceSegment segment);
+
+    /**
+     * @return The identifier for this sequence.
+     */
+    String getIdentifier();
+}

src/main/java/nl/tudelft/lifetiles/graph/SequenceGenerator.java

@@ -0,0 +1,64 @@
+package nl.tudelft.lifetiles.graph;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * @author Rutger van den Berg
+ *         Class that derives seperate sequences from a sequencegraph.
+ */
+public class SequenceGenerator {
+    /**
+     * The graph from which the sequences are derived.
+     */
+    private Graph<SequenceSegment> sourceGraph;
+    /**
+     * keep track of which segments have been processed.
+     */
+    private Map<SequenceSegment, Boolean> processed;
+    /**
+     * the generated sequences.
+     */
+    private List<Sequence> sequences;
+
+    /**
+     * @param graph
+     *            A DAG graph for which to generate sequences.
+     */
+    public SequenceGenerator(final Graph<SequenceSegment> graph) {
+        sourceGraph = graph;
+    }
+
+    /**
+     * @return A list of sequences
+     */
+    public final List<Sequence> generateSequences() {
+        processed = new HashMap<>();
+        sequences = new ArrayList<>();
+        for (SequenceSegment segment : sourceGraph.getSource()) {
+            generateSequences(segment);
+        }
+        return sequences;
+    }
+
+    /**
+     * Helper for generating sequences.
+     *
+     * @param vertex
+     *            The vertex from which to start adding segments.
+     */
+    private void generateSequences(final SequenceSegment vertex) {
+        for (Sequence seq : vertex.getSources()) {
+            seq.appendSegment(vertex);
+        }
+        for (Edge<SequenceSegment> edge : sourceGraph.getOutgoing(vertex)) {
+            SequenceSegment candidate = sourceGraph.getDestination(edge);
+            if (!processed.containsKey(candidate)) {
+                processed.put(candidate, new Boolean(true));
+                generateSequences(candidate);
+            }
+        }
+    }
+}

src/main/java/nl/tudelft/lifetiles/graph/SequenceImplementation.java

@@ -0,0 +1,46 @@
+package nl.tudelft.lifetiles.graph;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author Rutger van den Berg
+ *         Contains an entire sequence.
+ */
+public class SequenceImplementation implements Sequence {
+    /**
+     * List of sequence segments related to this sequence.
+     */
+    private List<SequenceSegment> sequenceList;
+    /**
+     * Identifier for this sequence.
+     */
+    private String ident;
+
+    /**
+     * @param identifier
+     *            The identifier for this sequence.
+     */
+    public SequenceImplementation(final String identifier) {
+        ident = identifier;
+        sequenceList = new ArrayList<>();
+    }
+
+    @Override
+    public final List<SequenceSegment> getSegments() {
+
+        return sequenceList;
+    }
+
+    @Override
+    public final void appendSegment(final SequenceSegment segment) {
+        sequenceList.add(segment);
+
+    }
+
+    @Override
+    public final String getIdentifier() {
+        return ident;
+    }
+
+}

src/main/java/nl/tudelft/lifetiles/graph/SequenceSegment.java

@@ -9,7 +9,7 @@ public class SequenceSegment {
     /**
      * Contains the sources containing this segment.
      */
-    private Set<String> sourcesVar;
+    private Set<Sequence> sourcesVar;
 
     /**
      * The start position for this segment.
@@ -34,8 +34,9 @@ public class SequenceSegment {
      * @param content
      *            The content for this segment.
      */
-    public SequenceSegment(final Set<String> sources, final long startPosition,
-            final long endPosition, final String content) {
+    public SequenceSegment(final Set<Sequence> sources,
+            final long startPosition, final long endPosition,
+            final String content) {
         sourcesVar = sources;
         startVar = startPosition;
         endVar = endPosition;
@@ -45,7 +46,7 @@ public SequenceSegment(final Set<String> sources, final long startPosition,
     /**
      * @return the sources
      */
-    public final Set<String> getSources() {
+    public final Set<Sequence> getSources() {
         return sourcesVar;
     }
 

src/test/java/nl/tudelft/lifetiles/controller/ViewControllerTest.java

@@ -0,0 +1,63 @@
+package nl.tudelft.lifetiles.controller;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Observable;
+import java.util.Observer;
+import java.util.Set;
+
+import nl.tudelft.lifetiles.controller.ViewController;
+import nl.tudelft.lifetiles.graph.Sequence;
+import nl.tudelft.lifetiles.graph.SequenceImplementation;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.mockito.Mockito;
+
+public class ViewControllerTest {
+    ViewController controller;
+    Observer view;
+    Map<String, Sequence> sequences;
+    Sequence s1, s2, s3, s4;
+
+    @Rule
+    public ExpectedException thrown = ExpectedException.none();
+
+    @Before
+    public void setUp() throws Exception {
+        s1 = new SequenceImplementation("s1");
+        s2 = new SequenceImplementation("s2");
+        s3 = new SequenceImplementation("s3");
+        s4 = new SequenceImplementation("s4");
+        sequences = new HashMap<>();
+        sequences.put("s1", s1);
+        sequences.put("s2", s2);
+        sequences.put("s3", s3);
+        controller = new ViewController(sequences);
+    }
+
+    @Test
+    public void testSetWrongVisible() {
+        Set<Sequence> newSequences = new HashSet<>();
+        newSequences.add(s1);
+        newSequences.add(s4);
+        thrown.expect(IllegalArgumentException.class);
+        controller.setVisible(newSequences);
+    }
+
+    @Test
+    public void testObserve() {
+        view = Mockito.mock(Observer.class);
+        controller.addObserver(view);
+        Set<Sequence> newSequences = new HashSet<>();
+        newSequences.add(s1);
+        newSequences.add(s2);
+        controller.setVisible(newSequences);
+        Mockito.verify(view, Mockito.atLeastOnce()).update(
+                Mockito.<Observable> any(), Mockito.<Object> any());
+    }
+
+}