--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/artifacts/src/main/java/org/dive4elements/river/artifacts/uinfo/vegetationzones/VegetationZoneServerClientXChange.java	Wed Aug 15 13:22:00 2018 +0200
@@ -0,0 +1,195 @@
+/** Copyright (C) 2017 by Bundesanstalt für Gewässerkunde
+ * Software engineering by
+ *  Björnsen Beratende Ingenieure GmbH
+ *  Dr. Schumacher Ingenieurbüro für Wasser und Umwelt
+ *
+ * This file is Free Software under the GNU AGPL (>=v3)
+ * and comes with ABSOLUTELY NO WARRANTY! Check out the
+ * documentation coming with Dive4Elements River for details.
+ */
+package org.dive4elements.river.artifacts.uinfo.vegetationzones;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.TreeSet;
+
+import org.dive4elements.artifacts.CallContext;
+import org.dive4elements.river.artifacts.resources.Resources;
+import org.dive4elements.river.model.River;
+
+/**
+ * @author Domenico Nardi Tironi
+ *
+ */
+public class VegetationZoneServerClientXChange implements Comparable<VegetationZoneServerClientXChange> {
+
+    // IMMER ABGLEICHEN MIT VegetationZoneServerClientXChange.class Server und Client
+    public static final boolean HAS_COLORS_EDITABLE = false;
+
+    private static final String TABLE_CELL_SEPARATOR = "TABLE_CELL_SEPARATOR";
+    private static final String TABLE_ROW_SEPARATOR = "TABLE_ROW_SEPARATOR";
+    private final String zoneName;
+    private final int min_day_overflow;
+    private final int max_day_overflow;
+    private final String hexColor;
+
+    public static List<VegetationZoneServerClientXChange> parse(final String zonesRaw) {
+        final List<VegetationZoneServerClientXChange> resultList = new ArrayList<>();
+
+        final List<String[]> results = new ArrayList<>();
+        if (zonesRaw.contains(TABLE_ROW_SEPARATOR)) {
+            final String[] rows = zonesRaw.split(TABLE_ROW_SEPARATOR);
+            for (final String row : rows) {
+                if (row.contains(TABLE_CELL_SEPARATOR)) {
+                    final String[] result = row.split(TABLE_CELL_SEPARATOR);
+                    results.add(result);
+                }
+            }
+        }
+        for (final String[] zone : results) {
+
+            final VegetationZoneServerClientXChange helper = new VegetationZoneServerClientXChange(zone[0], Integer.valueOf(zone[1]), Integer.valueOf(zone[2]), zone[3]);
+            resultList.add(helper);
+        }
+
+        return resultList;
+    }
+
+    public static VegetationZoneServerClientXChange createFromTableEntry(final String zone, final String min_day_overflow, final String max_day_overflow, final String hexColor) {
+        return new VegetationZoneServerClientXChange(zone, Integer.valueOf(min_day_overflow), Integer.valueOf(max_day_overflow), hexColor); // Error-Handling?
+    }
+
+    private VegetationZoneServerClientXChange(final String zone, final Integer min_day_overflow, final Integer max_day_overflow, final String hexColor) {
+        this.zoneName = zone;
+        this.min_day_overflow = min_day_overflow;
+        this.max_day_overflow = max_day_overflow;
+        this.hexColor = hexColor;
+    }
+
+    public int getMax_day_overflow() {
+        return this.max_day_overflow;
+    }
+
+    public String getZoneName() {
+        if (this.zoneName == null || this.zoneName.equals("")) {
+            return "---";
+        }
+        return this.zoneName;
+    }
+
+    public String getHexColor() {
+        try {
+            final int test = Integer.decode(this.hexColor);
+            return this.hexColor;
+        }
+        catch (final NumberFormatException e) {
+            return "#ffffff";
+        }
+    }
+
+    public int getMin_day_overflow() {
+        return this.min_day_overflow;
+    }
+
+    public static final List<VegetationZoneServerClientXChange> getStandardList(final River river, final CallContext context) {
+
+        final List<VegetationZoneServerClientXChange> list = new ArrayList<>();
+        for (final org.dive4elements.river.model.uinfo.VegetationZone vz : org.dive4elements.river.model.uinfo.VegetationZone.getValues(river)) {
+            final String zn = Resources.getMsg(context.getMeta(), "uinfo_vegetation_type_" + vz.getVegetationType().getId().toString());
+            list.add(new VegetationZoneServerClientXChange(zn, vz.getMin_overflow_days(), vz.getMax_overflow_days(), vz.getColor()));
+        }
+        return list;
+    }
+
+    public static final String parseListToDataString(final List<VegetationZoneServerClientXChange> list) {
+
+        java.util.Collections.sort(list);
+        final StringBuilder builder = new StringBuilder();
+        for (final VegetationZoneServerClientXChange zone : list) {
+            builder.append(zone.getZoneName());
+            builder.append(TABLE_CELL_SEPARATOR);
+            builder.append(zone.getMin_day_overflow());
+            builder.append(TABLE_CELL_SEPARATOR);
+            builder.append(zone.getMax_day_overflow());
+            builder.append(TABLE_CELL_SEPARATOR);
+            builder.append(zone.getHexColor());
+            builder.append(TABLE_ROW_SEPARATOR);
+        }
+        return builder.toString();
+
+    }
+
+    @Override
+    public int compareTo(final VegetationZoneServerClientXChange o) {
+        final int basicCompare = Integer.valueOf(this.getMin_day_overflow()).compareTo(o.getMin_day_overflow());
+        if (basicCompare == 0)
+            return Integer.valueOf(this.getMax_day_overflow()).compareTo(o.getMax_day_overflow()); // wenn min==min && max==max, alphabetisch sortieren?
+
+        if (basicCompare == 0) {
+            return 1; // for treeSet
+        }
+
+        return basicCompare;
+    }
+
+    public static final boolean zonesAreOverlapping(final List<VegetationZoneServerClientXChange> list) {
+        for (final VegetationZoneServerClientXChange zone : list) {
+            for (final VegetationZoneServerClientXChange zoneOther : list) {
+                if (zone != zoneOther) {
+                    final boolean overlaps = zone.overlaps(zoneOther);
+                    if (overlaps) {
+                        return overlaps; // cancel. only one zone has to overlap
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
+    public static final boolean hasGaps(final List<VegetationZoneServerClientXChange> list, final int lower, final int upper) {
+
+        if ((upper - lower) == 0)
+            return true;
+
+        final TreeSet<VegetationZoneServerClientXChange> treeList = new TreeSet<>();
+        treeList.addAll(list);
+        int lowerCompare = lower;
+        for (final VegetationZoneServerClientXChange zone : treeList) {
+            if (zone.getLowerFromTo() > (lowerCompare + 1)) { // nicht inklusiv
+                return true;
+            }
+            lowerCompare = zone.getUpperFromTo();
+        }
+        if ((lowerCompare) < upper)
+            return true; // am Ende nicht geschlossen
+
+        return false;
+    }
+
+    private boolean overlaps(final VegetationZoneServerClientXChange otherZone) {
+        final int otherLower = otherZone.getLowerFromTo();
+        final int otherUpper = otherZone.getUpperFromTo();
+
+        final int upper = getUpperFromTo();
+        final int lower = getLowerFromTo();
+        final int otherSchwerpunkt = (otherLower + otherUpper) / 2;
+        if ((otherUpper <= upper && otherUpper >= lower)) {
+            return true;
+        } else if (otherLower >= lower && otherLower <= upper) {
+            return true;
+        } else if (otherSchwerpunkt >= (lower) && otherSchwerpunkt <= (upper)) {
+            return true;
+        }
+        return false;
+    }
+
+    public Integer getLowerFromTo() {
+        return this.min_day_overflow < this.max_day_overflow ? this.min_day_overflow : this.max_day_overflow; // Math. is forbidden :-(
+    }
+
+    public Integer getUpperFromTo() {
+        return this.min_day_overflow > this.max_day_overflow ? this.min_day_overflow : this.max_day_overflow;// Math. is forbidden :-(
+    }
+
+}