--- a/backend/src/main/java/org/dive4elements/river/importer/parsers/WaterlevelDifferencesParser.java	Sun Apr 08 18:09:32 2018 +0200
+++ b/backend/src/main/java/org/dive4elements/river/importer/parsers/WaterlevelDifferencesParser.java	Mon Apr 09 09:07:00 2018 +0200
@@ -12,22 +12,20 @@
 import java.io.IOException;
 import java.math.BigDecimal;
 import java.text.NumberFormat;
-import java.text.ParseException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 import org.apache.log4j.Logger;
-
+import org.dive4elements.river.backend.utils.DateUtil;
 import org.dive4elements.river.importer.ImportTimeInterval;
 import org.dive4elements.river.importer.ImportUnit;
-
 import org.dive4elements.river.importer.ImportWst;
-import org.dive4elements.river.importer.ImportWstQRange;
 import org.dive4elements.river.importer.ImportWstColumn;
 import org.dive4elements.river.importer.ImportWstColumnValue;
-import org.dive4elements.river.backend.utils.DateUtil;
+import org.dive4elements.river.importer.ImportWstQRange;
+import org.dive4elements.river.importer.common.AbstractParser;
 
 
 /**
@@ -36,21 +34,21 @@
 public class WaterlevelDifferencesParser extends LineParser {
 
     private static final Logger log =
-        Logger.getLogger(WaterlevelDifferencesParser.class);
+            Logger.getLogger(WaterlevelDifferencesParser.class);
 
     private static final NumberFormat nf =
-        NumberFormat.getInstance(DEFAULT_LOCALE);
+            NumberFormat.getInstance(DEFAULT_LOCALE);
 
     public static final Pattern META_UNIT =
-        Pattern.compile("^Einheit: \\[(.*)\\].*");
+            Pattern.compile("^Einheit: \\[(.*)\\].*");
 
     public static final Pattern YEARS_IN_COLUMN =
-        Pattern.compile(".*(\\d{4})-(\\d{4})$");
+            Pattern.compile(".*(\\d{4})-(\\d{4})$");
 
-    public static final double INTERVAL_GAP = 0.00001d;
+    public static final BigDecimal INTERVAL_GAP = new BigDecimal("0.00001");
 
     /** List of parsed differences as ImportWst s. */
-    private List<ImportWst> differences;
+    private final List<ImportWst> differences;
 
     private ImportWstColumn[] columns;
 
@@ -59,13 +57,13 @@
 
 
     public WaterlevelDifferencesParser() {
-        differences = new ArrayList<ImportWst>();
+        this.differences = new ArrayList<>();
     }
 
 
     /** Get the differences as wst parsed so far. */
     public List<ImportWst> getDifferences() {
-        return differences;
+        return this.differences;
     }
 
 
@@ -74,9 +72,9 @@
      * from it.
      */
     @Override
-    public void parse(File file) throws IOException {
-        current = new ImportWst(file.getName());
-        current.setKind(6);
+    public void parse(final File file) throws IOException {
+        this.current = new ImportWst(file.getName());
+        this.current.setKind(6);
 
         super.parse(file);
     }
@@ -90,14 +88,14 @@
 
     @Override
     protected void finish() {
-        if (columns != null && current != null) {
+        if (this.columns != null && this.current != null) {
             // TODO figure out if its needed, as the columns
             //      are registered at their construction time.
-            for (ImportWstColumn col: columns) {
+            for (final ImportWstColumn col: this.columns) {
                 // TODO place a current.addColumn(col); here?
             }
 
-            differences.add(current);
+            this.differences.add(this.current);
         }
 
         // For all differences columns, add a single Q-Range with
@@ -106,27 +104,27 @@
         // TODO: should otherwise be extended to
         // (first station of next range - INTERVAL_GAP),
         // assuming always ascending stations
-        for (ImportWstColumn column: columns) {
-            List<ImportWstColumnValue> cValues = column.getColumnValues();
-            BigDecimal a = cValues.get(0).getPosition();
+        for (final ImportWstColumn column: this.columns) {
+            final List<ImportWstColumnValue> cValues = column.getColumnValues();
+            final BigDecimal a = cValues.get(0).getPosition();
             BigDecimal b = cValues.get(cValues.size() - 1).getPosition();
             if (a.compareTo(b) == 0) {
-                b = new BigDecimal(b.doubleValue() + INTERVAL_GAP);
+                b = b.add(INTERVAL_GAP);
             }
             column.addColumnQRange(
-                new ImportWstQRange(
-                    a,
-                    b,
-                    new BigDecimal(-1d))
-                );
+                    new ImportWstQRange(
+                            a,
+                            b,
+                            new BigDecimal(-1d))
+                    );
         }
-        current = null;
-        columns = null;
+        this.current = null;
+        this.columns = null;
     }
 
 
     @Override
-    protected void handleLine(int lineNum, String line) {
+    protected void handleLine(final int lineNum, final String line) {
         if (line.startsWith(START_META_CHAR)) {
             handleMetaLine(stripMetaLine(line));
         }
@@ -136,7 +134,7 @@
     }
 
 
-    private void handleMetaLine(String meta) {
+    private void handleMetaLine(final String meta) {
         if (handleMetaUnit(meta)) {
             return;
         }
@@ -146,14 +144,14 @@
     }
 
 
-    private boolean handleMetaUnit(String meta) {
-        Matcher m = META_UNIT.matcher(meta);
+    private boolean handleMetaUnit(final String meta) {
+        final Matcher m = META_UNIT.matcher(meta);
 
         if (m.matches()) {
-            String unit = m.group(1);
+            final String unit = m.group(1);
             log.debug("Found unit: '" + unit + "'");
 
-            current.setUnit(new ImportUnit(unit));
+            this.current.setUnit(new ImportUnit(unit));
 
             return true;
         }
@@ -162,13 +160,13 @@
     }
 
 
-    private boolean handleMetaColumnNames(String meta) {
-        Pattern META_COLUMN_NAMES = Pattern.compile("Fluss-km;(.*)");
-        Matcher m = META_COLUMN_NAMES.matcher(meta);
+    private boolean handleMetaColumnNames(final String meta) {
+        final Pattern META_COLUMN_NAMES = Pattern.compile("Fluss-km;(.*)");
+        final Matcher m = META_COLUMN_NAMES.matcher(meta);
 
         if (m.matches()) {
-            String colStr = m.group(1);
-            String[] cols = colStr.split(SEPERATOR_CHAR);
+            final String colStr = m.group(1);
+            final String[] cols = colStr.split(SEPERATOR_CHAR);
 
             log.debug("Found " + cols.length + " columns.");
 
@@ -182,28 +180,28 @@
 
 
     /** Setup column structures with name, description and time interval. */
-    private void initColumns(String[] cols) {
-        current.setNumberColumns(cols.length);
-        columns = current.getColumns().toArray(
-            new ImportWstColumn[cols.length]);
+    private void initColumns(final String[] cols) {
+        this.current.setNumberColumns(cols.length);
+        this.columns = this.current.getColumns().toArray(
+                new ImportWstColumn[cols.length]);
 
         for (int i = 0; i < cols.length; i++) {
-            String name = cols[i].replace("\"", "");
+            final String name = cols[i].replace("\"", "");
 
             log.debug("Create new column '" + name + "'");
-            ImportWstColumn column = current.getColumn(i);
+            final ImportWstColumn column = this.current.getColumn(i);
             column.setName(name);
             column.setDescription(name);
 
-            Matcher m = YEARS_IN_COLUMN.matcher(name);
+            final Matcher m = YEARS_IN_COLUMN.matcher(name);
 
             if (m.matches()) {
-                int startYear = Integer.parseInt(m.group(1));
-                int endYear   = Integer.parseInt(m.group(2));
-                ImportTimeInterval time = new ImportTimeInterval(
-                    DateUtil.getStartDateFromYear(startYear),
-                    DateUtil.getEndDateFromYear(endYear)
-                );
+                final int startYear = Integer.parseInt(m.group(1));
+                final int endYear   = Integer.parseInt(m.group(2));
+                final ImportTimeInterval time = new ImportTimeInterval(
+                        DateUtil.getStartDateFromYear(startYear),
+                        DateUtil.getEndDateFromYear(endYear)
+                        );
                 column.setTimeInterval(time);
             } else {
                 log.debug("No time interval in column header found: " + name);
@@ -215,9 +213,9 @@
     /** Handle one line of data, add one value for all columns.
      * @param line the line to parse
      */
-    private void handleDataLine(String line) {
+    private void handleDataLine(final String line) {
         // Split by separator, do not exclude trailing empty string.
-        String[] cols = line.split(SEPERATOR_CHAR, -1);
+        final String[] cols = line.split(SEPERATOR_CHAR, -1);
 
         if (cols == null || cols.length < 2) {
             log.warn("skip invalid waterlevel-diff line: '" + line + "'");
@@ -227,31 +225,31 @@
         try {
             // The first value in a line like 12,9;4,3;4,5 is the station,
             // later real values.
-            Double station = nf.parse(cols[0]).doubleValue();
+            final BigDecimal station = AbstractParser.parseDecimal(cols[0]);
 
-            for (int i = 0; i < columns.length; i++) {
-                int idx = i+1;
+            for (int i = 0; i < this.columns.length; i++) {
+                final int idx = i+1;
 
                 if (idx >= cols.length) {
                     log.warn("Insufficient column numbers: " + line);
                     continue;
                 }
 
-                String value = cols[idx];
+                final String value = cols[idx];
 
                 if (value != null && !value.equals("")) {
                     try {
-                        columns[i].addColumnValue(
-                            new BigDecimal(station),
-                            new BigDecimal(nf.parse(value).doubleValue()));
+                        this.columns[i].addColumnValue(
+                                station,
+                                AbstractParser.parseDecimal(value));
                     }
-                    catch (ParseException pe) {
+                    catch (final NumberFormatException pe) {
                         log.warn("Could not parse value: '" + value + "'");
                     }
                 }
             }
         }
-        catch (ParseException pe) {
+        catch (final NumberFormatException pe) {
             log.warn("Could not parse station: '" + line + "'");
         }
     }