metafacture-flux/ (main): Fix Checkstyle violations.

Author: blackwinter

config/checkstyle/checkstyle.xml

@@ -4,6 +4,10 @@
     "https://checkstyle.org/dtds/configuration_1_3.dtd">
 <module name="Checker">
     <module name="SuppressWarningsFilter" />
+    <module name="SuppressionSingleFilter">
+        <property name="checks" value=".*"/>
+        <property name="files" value="generated-src"/>
+    </module>
     <module name="TreeWalker">
         <module name="AbstractClassName"/>
         <module name="AnnotationUseStyle"/>

metafacture-flux/src/main/java/org/metafacture/flux/FluxCompiler.java

@@ -13,20 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.metafacture.flux;
 
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Map;
+import org.metafacture.flux.parser.FlowBuilder;
+import org.metafacture.flux.parser.FluxLexer;
+import org.metafacture.flux.parser.FluxParser;
+import org.metafacture.flux.parser.FluxProgramm;
 
 import org.antlr.runtime.ANTLRInputStream;
 import org.antlr.runtime.CommonTokenStream;
 import org.antlr.runtime.RecognitionException;
 import org.antlr.runtime.tree.CommonTreeNodeStream;
-import org.metafacture.flux.parser.FlowBuilder;
-import org.metafacture.flux.parser.FluxLexer;
-import org.metafacture.flux.parser.FluxParser;
-import org.metafacture.flux.parser.FluxProgramm;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
 
 /**
  * Creates a flow based on a flux script.
@@ -38,7 +40,7 @@ private FluxCompiler() {
         // no instances
     }
 
-    public static FluxProgramm compile(final InputStream flux, final Map<String,String> vars ) throws RecognitionException, IOException{
+    public static FluxProgramm compile(final InputStream flux, final Map<String, String> vars) throws RecognitionException, IOException {
         return compileFlow(compileAst(flux), vars);
     }
 

metafacture-flux/src/main/java/org/metafacture/flux/FluxParseException.java

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.metafacture.flux;
 
 import org.metafacture.framework.MetafactureException;

metafacture-flux/src/main/java/org/metafacture/flux/HelpPrinter.java

@@ -13,8 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.metafacture.flux;
 
+import org.metafacture.commons.ResourceUtil;
+import org.metafacture.commons.reflection.ObjectFactory;
+import org.metafacture.framework.MetafactureException;
+import org.metafacture.framework.annotations.Description;
+import org.metafacture.framework.annotations.In;
+import org.metafacture.framework.annotations.Out;
+import org.metafacture.framework.annotations.ReturnsAvailableArguments;
+
 import java.io.IOException;
 import java.io.PrintStream;
 import java.lang.reflect.InvocationTargetException;
@@ -24,16 +33,8 @@
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
-import java.util.Map;
 import java.util.Map.Entry;
-
-import org.metafacture.commons.ResourceUtil;
-import org.metafacture.commons.reflection.ObjectFactory;
-import org.metafacture.framework.MetafactureException;
-import org.metafacture.framework.annotations.Description;
-import org.metafacture.framework.annotations.In;
-import org.metafacture.framework.annotations.Out;
-import org.metafacture.framework.annotations.ReturnsAvailableArguments;
+import java.util.Map;
 
 /**
  * prints Flux help for a given {@link ObjectFactory}
@@ -58,28 +59,26 @@ public static void print(final ObjectFactory<?> factory,
         final List<String> keyWords = new ArrayList<String>();
         keyWords.addAll(factory.keySet());
         Collections.sort(keyWords);
-        for (String name : keyWords) {
+        for (final String name : keyWords) {
             describe(name, factory, out);
         }
     }
 
     private static String getVersionInfo() {
         try {
             return ResourceUtil.loadProperties("build.properties").toString();
-        } catch (IOException e) {
+        }
+        catch (final IOException e) {
             throw new MetafactureException("Failed to load build infos", e);
         }
     }
 
-    private static <T> void describe(String name, ObjectFactory<T> factory,
-            PrintStream out) {
+    private static <T> void describe(final String name, final ObjectFactory<T> factory, final PrintStream out) {
         final Class<? extends T> moduleClass = factory.get(name).getPlainClass();
         final Description desc = moduleClass.getAnnotation(Description.class);
 
         out.println(name);
-        name.chars().forEach(c-> {
-            out.print("-");
-        });
+        name.chars().forEach(c -> out.print("-"));
         out.println();
 
         if (desc != null) {
@@ -95,13 +94,14 @@ private static <T> void describe(String name, ObjectFactory<T> factory,
         if (!attributes.isEmpty()) {
             out.print("- options:\t");
             final StringBuilder builder = new StringBuilder();
-            for (Entry<String, Class<?>> entry : attributes.entrySet()) {
+            for (final Entry<String, Class<?>> entry : attributes.entrySet()) {
                 if (entry.getValue().isEnum()) {
                     builder.append(entry.getKey())
                             .append(" ")
                             .append(Arrays.asList(entry.getValue().getEnumConstants()))
                             .append(", ");
-                } else {
+                }
+                else {
                     builder.append(entry.getKey())
                             .append(" (")
                             .append(entry.getValue().getSimpleName())
@@ -128,14 +128,13 @@ private static <T> void describe(String name, ObjectFactory<T> factory,
     }
 
     @SuppressWarnings("unchecked")
-    private static Collection<String> getAvailableArguments(
-            Class<?> moduleClass) {
-        for (Method method : moduleClass.getMethods()) {
+    private static Collection<String> getAvailableArguments(final Class<?> moduleClass) {
+        for (final Method method : moduleClass.getMethods()) {
             if (method.getAnnotation(ReturnsAvailableArguments.class) != null) {
                 try {
                     return (Collection<String>) method.invoke(moduleClass);
-                } catch (IllegalAccessException | InvocationTargetException |
-                        IllegalArgumentException e) {
+                }
+                catch (final IllegalAccessException | InvocationTargetException | IllegalArgumentException e) {
                     // silently ignore
                 }
             }

metafacture-flux/src/main/java/org/metafacture/flux/parser/Flow.java

@@ -13,12 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.metafacture.flux.parser;
 
-import java.util.ArrayList;
-import java.util.Deque;
-import java.util.LinkedList;
-import java.util.List;
+package org.metafacture.flux.parser;
 
 import org.metafacture.flux.FluxParseException;
 import org.metafacture.framework.LifeCycle;
@@ -28,6 +24,10 @@
 import org.metafacture.framework.Tee;
 import org.metafacture.io.StdInOpener;
 
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
 
 /**
  * @author Markus Michael Geipel
@@ -42,9 +42,12 @@ final class Flow {
     private ObjectReceiver<? extends Object> start;
     private boolean joinLooseEnds;
 
-    @SuppressWarnings({ "unchecked", "rawtypes" })
+    Flow() {
+    }
+
+    @SuppressWarnings("unchecked")
     public void addElement(final Receiver nextElement) {
-        if(element==null){
+        if (element == null) {
             setStart((ObjectReceiver<? extends Object>) nextElement);
             return;
         }
@@ -55,19 +58,23 @@ public void addElement(final Receiver nextElement) {
                 for (final LifeCycle looseEnd : looseEndsStack.pop()) {
                     if (looseEnd instanceof Tee) {
                         ((Tee) looseEnd).addReceiver(nextElement);
-                    } else {
+                    }
+                    else {
                         ((Sender) looseEnd).setReceiver(nextElement);
                     }
                 }
                 joinLooseEnds = false;
-            } else {
+            }
+            else {
                 if (sender instanceof Tee) {
                     ((Tee) sender).addReceiver(nextElement);
-                } else {
+                }
+                else {
                     sender.setReceiver(nextElement);
                 }
             }
-        } else {
+        }
+        else {
             throw new FluxParseException(element.getClass().getCanonicalName() + "is not a sender");
         }
         element = nextElement;
@@ -78,7 +85,8 @@ public void startTee() {
             final Tee<?> tee = (Tee<?>) element;
             teeStack.push(tee);
             looseEndsStack.push(new ArrayList<LifeCycle>());
-        } else {
+        }
+        else {
             throw new FluxParseException("Flow cannot be split without a tee-element.");
         }
     }
@@ -93,7 +101,7 @@ public void endSubFlow() {
         element = teeStack.peek();
     }
 
-    private void setStart(final ObjectReceiver<? extends Object> start){
+    private void setStart(final ObjectReceiver<? extends Object> start) {
         this.start = start;
         element = start;
     }

metafacture-flux/src/main/java/org/metafacture/flux/parser/FluxProgramm.java

@@ -13,8 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.metafacture.flux.parser;
 
+import org.metafacture.commons.ResourceUtil;
+import org.metafacture.commons.reflection.ConfigurableClass;
+import org.metafacture.commons.reflection.ObjectFactory;
+import org.metafacture.commons.reflection.ReflectionUtil;
+import org.metafacture.flux.FluxParseException;
+import org.metafacture.flux.HelpPrinter;
+import org.metafacture.framework.Receiver;
+
 import java.io.IOException;
 import java.io.PrintStream;
 import java.net.URL;
@@ -27,14 +36,6 @@
 import java.util.Map;
 import java.util.Set;
 
-import org.metafacture.commons.ResourceUtil;
-import org.metafacture.commons.reflection.ConfigurableClass;
-import org.metafacture.commons.reflection.ObjectFactory;
-import org.metafacture.commons.reflection.ReflectionUtil;
-import org.metafacture.flux.FluxParseException;
-import org.metafacture.flux.HelpPrinter;
-import org.metafacture.framework.Receiver;
-
 /**
  * @author Markus Michael Geipel
  *
@@ -52,7 +53,8 @@ public final class FluxProgramm {
                 final URL url = enumeration.nextElement();
                 COMMAND_FACTORY.loadClassesFromMap(ResourceUtil.loadProperties(url), Receiver.class);
             }
-        } catch (final IOException e) {
+        }
+        catch (final IOException e) {
             throw new FluxParseException("unable to load properties.", e);
         }
     }
@@ -62,14 +64,18 @@ public final class FluxProgramm {
     private final Map<String, Wormhole> wormholeNameMapping = new HashMap<String, Wormhole>();
     private final Map<Flow, Wormhole> wormholeInFlowMapping = new Hashtable<Flow, Wormhole>();
 
+    public FluxProgramm() {
+    }
+
     private static Receiver createElement(final String name, final Map<String, String> namedArgs,
             final List<Object> cArgs) {
 
         final Receiver newElement;
         if (COMMAND_FACTORY.containsKey(name)) {
             newElement = COMMAND_FACTORY.newInstance(name, namedArgs, cArgs.toArray());
 
-        } else {
+        }
+        else {
             final ConfigurableClass<? extends Receiver> elementClass =
                     ReflectionUtil.loadClass(name, Receiver.class);
             newElement = elementClass.newInstance(namedArgs, cArgs.toArray());
@@ -156,7 +162,8 @@ public void start() {
             flow.start();
             if (!wormholeInFlowMapping.containsKey(flow)) {
                 flow.close();
-            } else {
+            }
+            else {
                 wormholeInFlowMapping.get(flow).finished(flow);
             }
         }
@@ -172,7 +179,7 @@ private static final class Wormhole {
         private Flow out;
         private final String name;
 
-        public Wormhole(final String name) {
+        Wormhole(final String name) {
             this.name = name;
         }
 

metafacture-flux/src/main/java/org/metafacture/flux/parser/StringSender.java

@@ -13,18 +13,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.metafacture.flux.parser;
 
 import org.metafacture.framework.ObjectReceiver;
 import org.metafacture.framework.helpers.DefaultObjectPipe;
 
-
 /**
  * Helper class to start a pipe with a {@link String}
  *
  * @author Markus Michael Geipel
  */
-public final class StringSender extends DefaultObjectPipe<Object, ObjectReceiver<String>>{
+public final class StringSender extends DefaultObjectPipe<Object, ObjectReceiver<String>> {
 
     private final String string;
 
@@ -34,9 +34,10 @@ public StringSender(final String string) {
 
     @Override
     public void process(final Object notUsed) {
-        if(notUsed==null){
-        getReceiver().process(string);
-        }else{
+        if (notUsed == null) {
+            getReceiver().process(string);
+        }
+        else {
             throw new IllegalArgumentException("Parameter not used. Must be null");
         }
     }

metafacture-flux/src/test/java/org/metafacture/flux/FluxGrammarTest.java

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.metafacture.flux;
 
 import static java.util.Collections.emptyMap;

metafacture-flux/src/test/java/org/metafacture/flux/FluxProgrammTest.java

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 package org.metafacture.flux;
 
 import java.io.IOException;