Fix javadoc for module "triples" (#396)

Author: dr0i

metafacture-triples/src/main/java/org/metafacture/triples/AbstractTripleSort.java

@@ -35,17 +35,20 @@
  * @author markus geipel
  *
  */
-public abstract class AbstractTripleSort extends DefaultObjectPipe<Triple, ObjectReceiver<Triple>> implements MemoryWarningSystem.Listener {
+public abstract class AbstractTripleSort extends DefaultObjectPipe<Triple, ObjectReceiver<Triple>>
+        implements MemoryWarningSystem.Listener {
+
     /**
-     * specifies the comparator
+     * Specifies the comparator. Can be one of {@link #SUBJECT}, {@link #PREDICATE},
+     * {@link #OBJECT}, {@link #ALL}.
      */
     public enum Compare {
         SUBJECT, PREDICATE, OBJECT, ALL
     }
 
     /**
-     * sort order
-     *
+     * Specifies the sort order.Can be one of {@link #INCREASING},
+     * {@link #DECREASING}.
      */
     public enum Order {
         INCREASING {
@@ -63,17 +66,17 @@ public int order(final int indicator) {
         public abstract int order(int indicator);
     }
 
-    private final List<Triple> buffer = new ArrayList<Triple>();
-    private final List<File> tempFiles;
+    private final List<Triple> buffer = new ArrayList<>();
+    private final List<File> tempFiles = new ArrayList<>();
     private Compare compare = Compare.SUBJECT;
     private Order order = Order.INCREASING;
     private volatile boolean memoryLow;
 
-    public AbstractTripleSort() {
+    /**
+     * Constructs an AbstractTripleSort. Calls {@link #MemoryWarningSystem}.
+     */
+    protected AbstractTripleSort() {
         MemoryWarningSystem.addListener(this);
-        tempFiles = new ArrayList<File>(); // Initialized here to let the
-                                            // compiler enforce the call to
-                                            // super() in subclasses.
     }
 
     @Override
@@ -192,6 +195,13 @@ public final Comparator<Triple> createComparator() {
         return createComparator(compare, order);
     }
 
+    /**
+     * Creates a Comparator.
+     *
+     * @param compareBy one of {@link #Compare}
+     * @param order     the {@link #Order}
+     * @return a Comparator of type Triple
+     */
     public static Comparator<Triple> createComparator(final Compare compareBy, final Order order) {
         final Comparator<Triple> comparator;
         switch (compareBy) {

metafacture-triples/src/main/java/org/metafacture/triples/SortedTripleFileFacade.java

@@ -37,6 +37,13 @@ public final class SortedTripleFileFacade {
     private Triple triple;
     private boolean empty;
 
+    /**
+     * Constructs a SortedTripleFileFacade with a file. Reads a Triple from the
+     * file.
+     *
+     * @param file the File to load a Triple from
+     * @throws IOException
+     */
     public SortedTripleFileFacade(final File file) throws IOException {
         this.file = file;
         in = new ObjectInputStream(new BufferedInputStream(new FileInputStream(file), BUFFERSIZE));
@@ -58,6 +65,10 @@ private void next() throws IOException {
         }
     }
 
+    /**
+     * Closes the {@link #ObjectInputStream} and deletes the {@value #file} it if it
+     * exists.
+     */
     public void close() {
         try {
             in.close();
@@ -70,13 +81,24 @@ public void close() {
         }
     }
 
+    /**
+     * Peeks at a Triple at the top of the stack.
+     *
+     * @return the Triple on top of the stack
+     */
     public Triple peek() {
         if (isEmpty()) {
             return null;
         }
         return triple;
     }
 
+    /**
+     * Pops a Triple from the stack.
+     *
+     * @return the Triple at the top of the stack.
+     * @throws IOException
+     */
     public Triple pop() throws IOException {
         final Triple nextTriple = peek();
         next();

metafacture-triples/src/main/java/org/metafacture/triples/TripleCollect.java

@@ -67,6 +67,11 @@ public void process(final Triple triple) {
         }
     }
 
+    /**
+     * Decodes a Triple. Passes the Predicate and the Object to the receiver.
+     *
+     * @param triple the Triple
+     */
     public void decodeTriple(final Triple triple) {
         if (triple.getObjectType() == ObjectType.STRING) {
             getReceiver().literal(triple.getPredicate(), triple.getObject());

metafacture-triples/src/main/java/org/metafacture/triples/TripleWriter.java

@@ -45,6 +45,11 @@ public final class TripleWriter extends DefaultObjectReceiver<Triple> {
 
     private ObjectOutputStream outputStream;
 
+    /**
+     * Constructs a TripleWriter with a given file name as output path.
+     *
+     * @param filename the name of the file to write to
+     */
     public TripleWriter(final String filename) {
         this.filename = filename;
         resetStream();