Add construct for Boundary creater and combiner

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/AbstractBoundary.java

@@ -2,14 +2,21 @@ package de.unikoblenz.fgbks.base.utils.boundary;
 
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheck;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombiner;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreater;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType;
 import de.unikoblenz.fgbks.base.utils.boundary.impl.InvalidBoundary;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VTypeRef;
 import java.util.HashMap;
+import java.util.Optional;
 import org.apache.commons.lang3.Validate;
 
 public abstract class AbstractBoundary<T extends Comparable<? super T>> implements Boundary {
 
   private HashMap<BoundaryCheckType, BoundaryCheck> checkFunctions;
+  private HashMap<BoundaryCombineType, BoundaryCombiner> combineFunctions;
+  private HashMap<BoundaryCreaterType, BoundaryCreater> createrFunctions;
   private Class<T> type;
   private String text;
 
@@ -19,6 +26,8 @@ public abstract class AbstractBoundary<T extends Comparable<? super T>> implemen
     parse(text);
     validate();
     checkFunctions = new HashMap<>(getChecker());
+    combineFunctions = new HashMap<>(getCombiner());
+    createrFunctions = new HashMap<>(getCreater());
   }
 
   @Override
@@ -36,11 +45,32 @@ public abstract class AbstractBoundary<T extends Comparable<? super T>> implemen
     if (other instanceof InvalidBoundary) {
       return false;
     }
-    BoundaryCheck checkFunction = getTestFunction(checkType);
+    BoundaryCheck checkFunction = getCheckFunction(checkType);
     if (checkFunction == null || !isValidOperation(checkType, other)) {
       throw new BoundaryOperationNotSupportedException(); // TODO: add error text
     }
-    return checkFunction.check(this, other);
+    return checkFunction.check(this, other); // TODO, remove RAW type
+  }
+
+  @Override
+  public Optional<Boundary> create(BoundaryCreaterType createrType) {
+    BoundaryCreater creater = getCreaterFunction(createrType);
+    if (creater == null || !isValidOperation(createrType)) {
+      throw new BoundaryOperationNotSupportedException(); // TODO: add error text
+    }
+    return creater.create(this);
+  }
+
+  @Override
+  public Optional<Boundary> combine(BoundaryCombineType combineType, Boundary other) {
+    if (other instanceof InvalidBoundary) {
+      return Optional.empty();
+    }
+    BoundaryCombiner combiner = getCombineFunction(combineType);
+    if (combiner == null || !isValidOperation(combineType, other)) {
+      throw new BoundaryOperationNotSupportedException(); // TODO: add error text
+    }
+    return combiner.combine(this, other); // TODO, remove RAW type
   }
 
   public boolean isValidOperation(BoundaryCheckType checkType, Boundary other) {
@@ -51,16 +81,40 @@ public abstract class AbstractBoundary<T extends Comparable<? super T>> implemen
     return checkFunctions.containsKey(Validate.notNull(checkType));
   }
 
-  protected BoundaryCheck getTestFunction(BoundaryCheckType checkType) {
+  public boolean isValidOperation(BoundaryCombineType combineType, Boundary other) {
+    return this.getTypeRef() == other.getTypeRef() && isValidOperation(combineType);
+  }
+
+  public boolean isValidOperation(BoundaryCombineType combineTyp) {
+    return combineFunctions.containsKey(Validate.notNull(combineTyp));
+  }
+
+  public boolean isValidOperation(BoundaryCreaterType createrType) {
+    return createrFunctions.containsKey(Validate.notNull(createrType));
+  }
+
+  protected BoundaryCheck getCheckFunction(BoundaryCheckType checkType) {
     return checkFunctions.get(checkType);
   }
 
+  protected BoundaryCreater getCreaterFunction(BoundaryCreaterType createrType) {
+    return createrFunctions.get(createrType);
+  }
+
+  protected BoundaryCombiner getCombineFunction(BoundaryCombineType combineTypeType) {
+    return combineFunctions.get(combineTypeType);
+  }
+
   protected abstract void parse(String text);
 
   protected abstract void validate();
 
   protected abstract HashMap<BoundaryCheckType, BoundaryCheck> getChecker();
 
+  protected abstract HashMap<BoundaryCombineType, BoundaryCombiner> getCombiner();
+
+  protected abstract HashMap<BoundaryCreaterType, BoundaryCreater> getCreater();
+
   protected abstract String getParsedText();
 
   @Override

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/AbstractGrowingBoundary.java

 package de.unikoblenz.fgbks.base.utils.boundary;
 
 import static de.unikoblenz.fgbks.base.utils.boundary.BoundType.INCLUSIVE;
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_EQUAL;
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_IN_CONTACT;
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_NOT_IN_CONTACT;
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_OVERLAPPING;
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.IS_SUBSUMPTION;
+import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.SUBSUMES;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.APPEND;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.BETWEEN;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.COMBINE;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.INTERSECTION;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.LOWER_BOUNDS;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.UPPER_BOUNDS;
+import static de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType.LOWER;
+import static de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType.UPPER;
 
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheck;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType;
@@ -10,6 +24,12 @@ import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckIsSubsumption;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckNotInContact;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckOverlap;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckSubsumes;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombiner;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.EmptyCombiner;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreater;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.EmptyCreater;
 import java.util.HashMap;
 import java.util.Objects;
 import org.apache.commons.lang3.Validate;
@@ -68,12 +88,32 @@ public abstract class AbstractGrowingBoundary<T extends Comparable<? super T>>
   @Override
   protected HashMap<BoundaryCheckType, BoundaryCheck> getChecker() {
     HashMap<BoundaryCheckType, BoundaryCheck> map = new HashMap<>();
-    map.put(BoundaryCheckType.IS_EQUAL, CheckEqual.getInstance());
-    map.put(BoundaryCheckType.IS_IN_CONTACT, CheckInContact.getInstance());
-    map.put(BoundaryCheckType.IS_NOT_IN_CONTACT, CheckNotInContact.getInstance());
-    map.put(BoundaryCheckType.IS_OVERLAPPING, CheckOverlap.getInstance());
-    map.put(BoundaryCheckType.IS_SUBSUMPTION, CheckIsSubsumption.getInstance());
-    map.put(BoundaryCheckType.SUBSUMES, CheckSubsumes.getInstance());
+    map.put(IS_EQUAL, CheckEqual.getInstance());
+    map.put(IS_IN_CONTACT, CheckInContact.getInstance());
+    map.put(IS_NOT_IN_CONTACT, CheckNotInContact.getInstance());
+    map.put(IS_OVERLAPPING, CheckOverlap.getInstance());
+    map.put(IS_SUBSUMPTION, CheckIsSubsumption.getInstance());
+    map.put(SUBSUMES, CheckSubsumes.getInstance());
+    return map;
+  }
+
+  @Override
+  protected HashMap<BoundaryCombineType, BoundaryCombiner> getCombiner() {
+    HashMap<BoundaryCombineType, BoundaryCombiner> map = new HashMap<>();
+    map.put(INTERSECTION, EmptyCombiner.getInstance());
+    map.put(LOWER_BOUNDS, EmptyCombiner.getInstance());
+    map.put(UPPER_BOUNDS, EmptyCombiner.getInstance());
+    map.put(BETWEEN, EmptyCombiner.getInstance());
+    map.put(APPEND, EmptyCombiner.getInstance());
+    map.put(COMBINE, EmptyCombiner.getInstance());
+    return map;
+  }
+
+  @Override
+  protected HashMap<BoundaryCreaterType, BoundaryCreater> getCreater() {
+    HashMap<BoundaryCreaterType, BoundaryCreater> map = new HashMap<>();
+    map.put(UPPER, EmptyCreater.getInstance());
+    map.put(LOWER, EmptyCreater.getInstance());
     return map;
   }
 

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/Boundary.java

 package de.unikoblenz.fgbks.base.utils.boundary;
 
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VTypeRef;
+import java.util.Optional;
 
 public interface Boundary extends Comparable<Boundary> {
 
@@ -10,4 +13,8 @@ public interface Boundary extends Comparable<Boundary> {
   String getText();
 
   boolean checkWith(BoundaryCheckType checkType, Boundary other);
+
+  Optional<Boundary> create(BoundaryCreaterType createType);
+
+  Optional<Boundary> combine(BoundaryCombineType combineType, Boundary other);
 }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringEqual.java

@@ -6,6 +6,10 @@ public class CheckStringEqual extends AbstractBoundaryCheck<StringBoundary> {
 
   private static CheckStringEqual instance = new CheckStringEqual();
 
+  private CheckStringEqual() {
+    super();
+  }
+
   public static CheckStringEqual getInstance() {
     return instance;
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringInContact.java

@@ -6,6 +6,10 @@ public class CheckStringInContact extends AbstractBoundaryCheck<StringBoundary>
 
   private static CheckStringInContact instance = new CheckStringInContact();
 
+  private CheckStringInContact() {
+    super();
+  }
+
   public static CheckStringInContact getInstance() {
     return instance;
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringNotInContact.java

@@ -6,6 +6,10 @@ public class CheckStringNotInContact extends AbstractBoundaryCheck<StringBoundar
 
   private static CheckStringNotInContact instance = new CheckStringNotInContact();
 
+  private CheckStringNotInContact() {
+    super();
+  }
+
   public static CheckStringNotInContact getInstance() {
     return instance;
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringOverlap.java

@@ -6,6 +6,10 @@ public class CheckStringOverlap extends AbstractBoundaryCheck<StringBoundary> {
 
   private static CheckStringOverlap instance = new CheckStringOverlap();
 
+  private CheckStringOverlap() {
+    super();
+  }
+
   public static CheckStringOverlap getInstance() {
     return instance;
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumes.java

@@ -6,6 +6,10 @@ public class CheckStringSubsumes extends AbstractBoundaryCheck<StringBoundary> {
 
   private static CheckStringSubsumes instance = new CheckStringSubsumes();
 
+  private CheckStringSubsumes() {
+    super();
+  }
+
   public static CheckStringSubsumes getInstance() {
     return instance;
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumption.java

@@ -6,6 +6,10 @@ public class CheckStringSubsumption extends AbstractBoundaryCheck<StringBoundary
 
   private static CheckStringSubsumption instance = new CheckStringSubsumption();
 
+  private CheckStringSubsumption() {
+    super();
+  }
+
   public static CheckStringSubsumption getInstance() {
     return instance;
   }

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/combiner/AbstractBoundaryCombiner.java

+package de.unikoblenz.fgbks.base.utils.boundary.combiner;
+
+import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
+
+public abstract class AbstractBoundaryCombiner<T extends Boundary> implements BoundaryCombiner<T> {}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/combiner/BoundaryCombineType.java

+package de.unikoblenz.fgbks.base.utils.boundary.combiner;
+
+public enum BoundaryCombineType {
+  INTERSECTION,
+  LOWER_BOUNDS,
+  UPPER_BOUNDS,
+  BETWEEN,
+  APPEND,
+  COMBINE;
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/combiner/BoundaryCombiner.java

+package de.unikoblenz.fgbks.base.utils.boundary.combiner;
+
+import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
+import java.util.Optional;
+
+public interface BoundaryCombiner<T extends Boundary> {
+
+  BoundaryCombineType getType();
+
+  Optional<T> combine(T b1, T b2);
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/combiner/EmptyCombiner.java

+package de.unikoblenz.fgbks.base.utils.boundary.combiner;
+
+import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
+import java.util.Optional;
+
+public class EmptyCombiner extends AbstractBoundaryCombiner<Boundary> {
+
+  private static final EmptyCombiner instance = new EmptyCombiner();
+
+  private EmptyCombiner() {
+    super();
+  }
+
+  public static EmptyCombiner getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryCombineType getType() {
+    return null;
+  }
+
+  @Override
+  public Optional<Boundary> combine(Boundary b1, Boundary b2) {
+    return Optional.empty();
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/AbstractBoundaryCreater.java

+package de.unikoblenz.fgbks.base.utils.boundary.creater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
+
+public abstract class AbstractBoundaryCreater<T extends Boundary> implements BoundaryCreater<T> {}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreater.java

+package de.unikoblenz.fgbks.base.utils.boundary.creater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
+import java.util.Optional;
+
+public interface BoundaryCreater<T extends Boundary> {
+
+  BoundaryCreaterType getType();
+
+  Optional<T> create(T b);
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreaterType.java

+package de.unikoblenz.fgbks.base.utils.boundary.creater;
+
+public enum BoundaryCreaterType {
+  LOWER,
+  UPPER;
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/EmptyCreater.java

+package de.unikoblenz.fgbks.base.utils.boundary.creater;
+
+import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
+import java.util.Optional;
+
+public class EmptyCreater extends AbstractBoundaryCreater<Boundary> {
+
+  private static final EmptyCreater instance = new EmptyCreater();
+
+  private EmptyCreater() {
+    super();
+  }
+
+  public static EmptyCreater getInstance() {
+    return instance;
+  }
+
+  @Override
+  public BoundaryCreaterType getType() {
+    return null;
+  }
+
+  @Override
+  public Optional<Boundary> create(Boundary b) {
+    return Optional.empty();
+  }
+}

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/impl/InvalidBoundary.java

@@ -2,7 +2,10 @@ package de.unikoblenz.fgbks.base.utils.boundary.impl;
 
 import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType;
 import de.unikoblenz.fgbks.core.dmn.domain.vdmn.VTypeRef;
+import java.util.Optional;
 
 public class InvalidBoundary implements Boundary {
 
@@ -29,6 +32,16 @@ public class InvalidBoundary implements Boundary {
     return false;
   }
 
+  @Override
+  public Optional<Boundary> create(BoundaryCreaterType createType) {
+    return Optional.empty();
+  }
+
+  @Override
+  public Optional<Boundary> combine(BoundaryCombineType combineType, Boundary other) {
+    return Optional.empty();
+  }
+
   @Override
   public int compareTo(Boundary o) {
     return 0;

dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/impl/StringBoundary.java

 package de.unikoblenz.fgbks.base.utils.boundary.impl;
 
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.APPEND;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.BETWEEN;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.COMBINE;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.INTERSECTION;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.LOWER_BOUNDS;
+import static de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType.UPPER_BOUNDS;
+import static de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType.LOWER;
+import static de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType.UPPER;
+
 import de.unikoblenz.fgbks.base.utils.boundary.AbstractBoundary;
 import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
 import de.unikoblenz.fgbks.base.utils.boundary.BoundaryParseException;
@@ -11,6 +20,12 @@ import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckStringNotInContact;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckStringOverlap;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckStringSubsumes;
 import de.unikoblenz.fgbks.base.utils.boundary.checker.CheckStringSubsumption;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombineType;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.BoundaryCombiner;
+import de.unikoblenz.fgbks.base.utils.boundary.combiner.EmptyCombiner;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreater;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.BoundaryCreaterType;
+import de.unikoblenz.fgbks.base.utils.boundary.creater.EmptyCreater;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Objects;
@@ -99,6 +114,26 @@ public class StringBoundary extends AbstractBoundary<String> {
     return map;
   }
 
+  @Override
+  protected HashMap<BoundaryCombineType, BoundaryCombiner> getCombiner() {
+    HashMap<BoundaryCombineType, BoundaryCombiner> map = new HashMap<>();
+    map.put(INTERSECTION, EmptyCombiner.getInstance());
+    map.put(LOWER_BOUNDS, EmptyCombiner.getInstance());
+    map.put(UPPER_BOUNDS, EmptyCombiner.getInstance());
+    map.put(BETWEEN, EmptyCombiner.getInstance());
+    map.put(APPEND, EmptyCombiner.getInstance());
+    map.put(COMBINE, EmptyCombiner.getInstance());
+    return map;
+  }
+
+  @Override
+  protected HashMap<BoundaryCreaterType, BoundaryCreater> getCreater() {
+    HashMap<BoundaryCreaterType, BoundaryCreater> map = new HashMap<>();
+    map.put(UPPER, EmptyCreater.getInstance());
+    map.put(LOWER, EmptyCreater.getInstance());
+    return map;
+  }
+
   @Override
   protected String getParsedText() {
     return (matchNoneOfValues ? "not" : "") + Arrays.toString(values);