From 9b94d9eb1445bfebb27ecab8840a93bd3c1553ca Mon Sep 17 00:00:00 2001
From: Jonas Blatt <jonasblatt@uni-koblenz.de>
Date: Sat, 5 Oct 2019 17:30:40 +0200
Subject: [PATCH] Add documentation for boundary creater, checker
---
.../boundary/bicreater/BiCreaterAppend.java | 11 +++++++
.../boundary/bicreater/BiCreaterBetween.java | 31 +++++++++++------
.../boundary/bicreater/BiCreaterCombine.java | 11 +++++++
.../bicreater/BiCreaterIntersection.java | 11 +++++++
.../bicreater/BiCreaterLowerBounds.java | 11 +++++++
.../bicreater/BiCreaterStringAppend.java | 11 +++++++
.../bicreater/BiCreaterStringBetween.java | 11 +++++++
.../bicreater/BiCreaterStringCombine.java | 11 +++++++
.../BiCreaterStringIntersection.java | 11 +++++++
.../bicreater/BiCreaterStringLowerBounds.java | 10 ++++++
.../bicreater/BiCreaterStringUpperBounds.java | 10 ++++++
.../bicreater/BiCreaterUpperBounds.java | 11 +++++++
.../boundary/bicreater/BoundaryBiCreater.java | 18 ++++++++++
.../bicreater/BoundaryBiCreaterType.java | 26 ++++++++++++++-
.../boundary/bicreater/EmptyBiCreater.java | 8 +++++
.../utils/boundary/checker/BoundaryCheck.java | 18 ++++++++++
.../boundary/checker/BoundaryCheckType.java | 26 ++++++++++++++-
.../utils/boundary/checker/CheckEqual.java | 17 ++++++++++
.../boundary/checker/CheckInContact.java | 21 ++++++++++++
.../boundary/checker/CheckIsSubsumption.java | 21 ++++++++++++
.../boundary/checker/CheckNotInContact.java | 23 +++++++++++++
.../utils/boundary/checker/CheckOverlap.java | 17 ++++++++++
.../boundary/checker/CheckStringEqual.java | 17 ++++++++++
.../checker/CheckStringInContact.java | 18 +++++++++-
.../checker/CheckStringNotInContact.java | 18 +++++++++-
.../boundary/checker/CheckStringOverlap.java | 17 ++++++++++
.../boundary/checker/CheckStringSubsumes.java | 20 +++++++++++
.../checker/CheckStringSubsumption.java | 8 +++++
.../utils/boundary/checker/CheckSubsumes.java | 33 +++++++++++++++----
.../boundary/creater/BoundaryCreater.java | 17 ++++++++++
.../boundary/creater/BoundaryCreaterType.java | 10 +++++-
.../utils/boundary/creater/CreaterLower.java | 10 ++++++
.../boundary/creater/CreaterStringLower.java | 22 ++++++++++---
.../boundary/creater/CreaterStringUpper.java | 12 +++++++
.../utils/boundary/creater/CreaterUpper.java | 10 ++++++
.../utils/boundary/creater/EmptyCreater.java | 5 +++
36 files changed, 535 insertions(+), 27 deletions(-)
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterAppend.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterAppend.java
index 848b72e0..0a0a56bd 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterAppend.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterAppend.java
@@ -9,6 +9,12 @@ import de.unikoblenz.fgbks.base.utils.boundary.impl.IntegerBoundary;
import de.unikoblenz.fgbks.base.utils.boundary.impl.LongBoundary;
import java.util.Optional;
+/**
+ * The combine creator implementation of {@link BoundaryBiCreaterType#APPEND} for {@link
+ * AbstractGrowingBoundary}. <br> The result is a new boundary with the combined range of both
+ * boundaries, or an empty optional, if the creation is not possible. Both boundaries are not in
+ * contact. <br> In: {@code b1: [10..30[; b2: [30..50]} <br> Out: {@code ]10..50[} <br>
+ */
public class BiCreaterAppend extends AbstractBoundaryBiCreater<AbstractGrowingBoundary> {
private static final BiCreaterAppend instance = new BiCreaterAppend();
@@ -17,6 +23,11 @@ public class BiCreaterAppend extends AbstractBoundaryBiCreater<AbstractGrowingBo
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterAppend getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterBetween.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterBetween.java
index f76d28bf..e3a18b33 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterBetween.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterBetween.java
@@ -9,6 +9,12 @@ import de.unikoblenz.fgbks.base.utils.boundary.impl.DoubleBoundary;
import de.unikoblenz.fgbks.base.utils.boundary.impl.IntegerBoundary;
import java.util.Optional;
+/**
+ * The between creator implementation of {@link BoundaryBiCreaterType#BETWEEN} for {@link
+ * AbstractGrowingBoundary}. <br> The result is a new boundary with boundary between the both
+ * boundaries, or an empty optional, if the creation is not possible. <br> In: {@code b1: [10..20];
+ * b2: [30..50]} <br> Out: {@code ]20..30[} <br>
+ */
public class BiCreaterBetween extends AbstractBoundaryBiCreater<AbstractGrowingBoundary> {
private static final BiCreaterBetween instance = new BiCreaterBetween();
@@ -17,6 +23,11 @@ public class BiCreaterBetween extends AbstractBoundaryBiCreater<AbstractGrowingB
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterBetween getInstance() {
return instance;
}
@@ -34,9 +45,9 @@ public class BiCreaterBetween extends AbstractBoundaryBiCreater<AbstractGrowingB
}
// no space between the two bounds
if (b1.getUpperBound().equals(b2.getLowerBound())
- && !b1.getUpperBound().equals(b2.getLowerBound())
+ && !b1.getUpperBound().equals(b2.getLowerBound())
|| b2.getUpperBound().equals(b1.getLowerBound())
- && !b2.getUpperBound().equals(b1.getLowerBound())) {
+ && !b2.getUpperBound().equals(b1.getLowerBound())) {
return Optional.empty();
}
if (b1 instanceof IntegerBoundary) {
@@ -45,11 +56,11 @@ public class BiCreaterBetween extends AbstractBoundaryBiCreater<AbstractGrowingB
int b2L = (int) b1.getLowerBound();
int b2U = (int) b1.getUpperBound();
if (b1U + 1 == b2L
- && b1.getUpperBoundType() == INCLUSIVE
- && b2.getLowerBoundType() == INCLUSIVE
+ && b1.getUpperBoundType() == INCLUSIVE
+ && b2.getLowerBoundType() == INCLUSIVE
|| b2U + 1 == b1L
- && b2.getUpperBoundType() == INCLUSIVE
- && b1.getLowerBoundType() == INCLUSIVE) {
+ && b2.getUpperBoundType() == INCLUSIVE
+ && b1.getLowerBoundType() == INCLUSIVE) {
return Optional.empty();
}
}
@@ -59,11 +70,11 @@ public class BiCreaterBetween extends AbstractBoundaryBiCreater<AbstractGrowingB
long b2L = (long) b1.getLowerBound();
long b2U = (long) b1.getUpperBound();
if (b1U + 1 == b2L
- && b1.getUpperBoundType() == INCLUSIVE
- && b2.getLowerBoundType() == INCLUSIVE
+ && b1.getUpperBoundType() == INCLUSIVE
+ && b2.getLowerBoundType() == INCLUSIVE
|| b2U + 1 == b1L
- && b2.getUpperBoundType() == INCLUSIVE
- && b1.getLowerBoundType() == INCLUSIVE) {
+ && b2.getUpperBoundType() == INCLUSIVE
+ && b1.getLowerBoundType() == INCLUSIVE) {
return Optional.empty();
}
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterCombine.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterCombine.java
index 303e7e8e..6fa9683e 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterCombine.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterCombine.java
@@ -8,6 +8,12 @@ import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
import java.util.Optional;
+/**
+ * The combine creator implementation of {@link BoundaryBiCreaterType#COMBINE} for {@link
+ * AbstractGrowingBoundary}. <br> The result is a new boundary with the combined range of both
+ * boundaries, or an empty optional, if the creation is not possible. <br> In: {@code b1: [10..20];
+ * b2: [15..30]} <br> Out: {@code [10..30]} <br>
+ */
public class BiCreaterCombine extends AbstractBoundaryBiCreater<AbstractGrowingBoundary> {
private static final BiCreaterCombine instance = new BiCreaterCombine();
@@ -16,6 +22,11 @@ public class BiCreaterCombine extends AbstractBoundaryBiCreater<AbstractGrowingB
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterCombine getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterIntersection.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterIntersection.java
index c9774699..23f11274 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterIntersection.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterIntersection.java
@@ -6,6 +6,12 @@ import static de.unikoblenz.fgbks.base.utils.boundary.checker.BoundaryCheckType.
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
import java.util.Optional;
+/**
+ * The intersection creator implementation of {@link BoundaryBiCreaterType#INTERSECTION} for {@link
+ * AbstractGrowingBoundary}. <br> The result is a new boundary with intersection of both boundaries,
+ * or an empty optional, if the creation is not possible. <br> In: {@code b1: [10..20]; b2:
+ * [15..30]} <br> Out: {@code [15..20]} <br>
+ */
public class BiCreaterIntersection extends AbstractBoundaryBiCreater<AbstractGrowingBoundary> {
private static final BiCreaterIntersection instance = new BiCreaterIntersection();
@@ -14,6 +20,11 @@ public class BiCreaterIntersection extends AbstractBoundaryBiCreater<AbstractGro
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterIntersection getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterLowerBounds.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterLowerBounds.java
index 2a385096..c4831fab 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterLowerBounds.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterLowerBounds.java
@@ -9,6 +9,12 @@ import de.unikoblenz.fgbks.base.utils.boundary.impl.IntegerBoundary;
import de.unikoblenz.fgbks.base.utils.boundary.impl.LongBoundary;
import java.util.Optional;
+/**
+ * The lower bound creator implementation of {@link BoundaryBiCreaterType#LOWER_BOUNDS} for {@link
+ * AbstractGrowingBoundary}. <br> The result is a new boundary with the lower bounds, or an empty
+ * optional, if the creation is not possible. <br> In: {@code b1: [10..20]; b2: [15..30]} <br> Out:
+ * {@code [10..15[} <br>
+ */
public class BiCreaterLowerBounds extends AbstractBoundaryBiCreater<AbstractGrowingBoundary> {
private static final BiCreaterLowerBounds instance = new BiCreaterLowerBounds();
@@ -17,6 +23,11 @@ public class BiCreaterLowerBounds extends AbstractBoundaryBiCreater<AbstractGrow
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterLowerBounds getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringAppend.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringAppend.java
index dc77ebb0..a4a9cae6 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringAppend.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringAppend.java
@@ -7,6 +7,12 @@ import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
import java.util.Optional;
+/**
+ * The between creator implementation of {@link BoundaryBiCreaterType#BETWEEN} for {@link
+ * StringBoundary}. <br> The result is a new boundary with boundary between the both boundaries, or
+ * an empty optional, if the creation is not possible. The boundaries are not in contact. <br> In:
+ * {@code b1: "a"; b2: "b"} <br> Out: {@code not("a","b")} <br>
+ */
public class BiCreaterStringAppend extends AbstractBoundaryBiCreater<StringBoundary> {
private static final BiCreaterStringAppend instance = new BiCreaterStringAppend();
@@ -15,6 +21,11 @@ public class BiCreaterStringAppend extends AbstractBoundaryBiCreater<StringBound
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterStringAppend getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringBetween.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringBetween.java
index 295615f5..576e8419 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringBetween.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringBetween.java
@@ -6,6 +6,12 @@ import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
+/**
+ * The between creator implementation of {@link BoundaryBiCreaterType#BETWEEN} for {@link
+ * StringBoundary}. <br> The result is a new boundary with boundary between the both boundaries, or
+ * an empty optional, if the creation is not possible. <br> In: {@code b1: "a"; b2: "b"} <br> Out:
+ * {@code not("a","b")} <br>
+ */
public class BiCreaterStringBetween extends AbstractBoundaryBiCreater<StringBoundary> {
private static final BiCreaterStringBetween instance = new BiCreaterStringBetween();
@@ -14,6 +20,11 @@ public class BiCreaterStringBetween extends AbstractBoundaryBiCreater<StringBoun
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterStringBetween getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringCombine.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringCombine.java
index 50f6c12a..dfa683e4 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringCombine.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringCombine.java
@@ -6,6 +6,12 @@ import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
+/**
+ * The combine creator implementation of {@link BoundaryBiCreaterType#COMBINE} for {@link
+ * StringBoundary}. <br> The result is a new boundary with the combined range of both boundaries, or
+ * an empty optional, if the creation is not possible. <br> In: {@code b1: "a"; b2: "b"} <br> Out:
+ * {@code "a","b"} <br>
+ */
public class BiCreaterStringCombine extends AbstractBoundaryBiCreater<StringBoundary> {
private static final BiCreaterStringCombine instance = new BiCreaterStringCombine();
@@ -14,6 +20,11 @@ public class BiCreaterStringCombine extends AbstractBoundaryBiCreater<StringBoun
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterStringCombine getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringIntersection.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringIntersection.java
index 2cbe4f9f..d377c390 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringIntersection.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringIntersection.java
@@ -10,6 +10,12 @@ import java.util.Objects;
import java.util.Optional;
import java.util.Set;
+/**
+ * The intersection creator implementation of {@link BoundaryBiCreaterType#INTERSECTION} for {@link
+ * StringBoundary}. <br> The result is a new boundary with intersection of both boundaries, or an
+ * empty optional, if the creation is not possible. <br> In: {@code b1: "a" b2: "a","b"} <br> Out:
+ * {@code "a"} <br>
+ */
public class BiCreaterStringIntersection extends AbstractBoundaryBiCreater<StringBoundary> {
private static final BiCreaterStringIntersection instance = new BiCreaterStringIntersection();
@@ -18,6 +24,11 @@ public class BiCreaterStringIntersection extends AbstractBoundaryBiCreater<Strin
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterStringIntersection getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringLowerBounds.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringLowerBounds.java
index 6cab93a7..3dd7e3a9 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringLowerBounds.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringLowerBounds.java
@@ -9,6 +9,11 @@ import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
+/**
+ * The lower bound creator implementation of {@link BoundaryBiCreaterType#LOWER_BOUNDS} for {@link
+ * StringBoundary}. <br> The result is a new boundary with the lower bounds, or an empty optional,
+ * if the creation is not possible. <br> In: {@code b1: "a","b"; b2: "a"}<br> Out: {@code "b"} <br>
+ */
public class BiCreaterStringLowerBounds extends AbstractBoundaryBiCreater<StringBoundary> {
private static final BiCreaterStringLowerBounds instance = new BiCreaterStringLowerBounds();
@@ -17,6 +22,11 @@ public class BiCreaterStringLowerBounds extends AbstractBoundaryBiCreater<String
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterStringLowerBounds getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringUpperBounds.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringUpperBounds.java
index 1f449d70..04574156 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringUpperBounds.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterStringUpperBounds.java
@@ -3,6 +3,11 @@ package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
import java.util.Optional;
+/**
+ * The upper bound creator implementation of {@link BoundaryBiCreaterType#UPPER_BOUNDS} for {@link
+ * StringBoundary}. <br> The result is a new boundary is always empty. See {@link
+ * BiCreaterStringLowerBounds} instead.
+ */
public class BiCreaterStringUpperBounds extends AbstractBoundaryBiCreater<StringBoundary> {
private static final BiCreaterStringUpperBounds instance = new BiCreaterStringUpperBounds();
@@ -11,6 +16,11 @@ public class BiCreaterStringUpperBounds extends AbstractBoundaryBiCreater<String
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterStringUpperBounds getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterUpperBounds.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterUpperBounds.java
index eec40d2a..e0c531dd 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterUpperBounds.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BiCreaterUpperBounds.java
@@ -9,6 +9,12 @@ import de.unikoblenz.fgbks.base.utils.boundary.impl.IntegerBoundary;
import de.unikoblenz.fgbks.base.utils.boundary.impl.LongBoundary;
import java.util.Optional;
+/**
+ * The upper bound creator implementation of {@link BoundaryBiCreaterType#UPPER_BOUNDS} for {@link
+ * AbstractGrowingBoundary}. <br> The result is a new boundary with the upper bounds, or an empty
+ * optional, if the creation is not possible. <br> In: {@code b1: [10..20]; b2: [15..30]} <br> Out:
+ * {@code ]20..30]} <br>
+ */
public class BiCreaterUpperBounds extends AbstractBoundaryBiCreater<AbstractGrowingBoundary> {
private static final BiCreaterUpperBounds instance = new BiCreaterUpperBounds();
@@ -17,6 +23,11 @@ public class BiCreaterUpperBounds extends AbstractBoundaryBiCreater<AbstractGrow
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static BiCreaterUpperBounds getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreater.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreater.java
index 0a706080..2f1ad60b 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreater.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreater.java
@@ -3,9 +3,27 @@ package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
import java.util.Optional;
+/**
+ * The biCreater interface. Used to create a new Boundary of a given one and an other boundary with
+ * a modification, specified by the {@link BoundaryBiCreaterType}.
+ *
+ * @param <T> the boundary type
+ */
public interface BoundaryBiCreater<T extends Boundary> {
+ /**
+ * Get the {@link BoundaryBiCreaterType}.
+ *
+ * @return the {@link BoundaryBiCreaterType}
+ */
BoundaryBiCreaterType getType();
+ /**
+ * Perform the creation of a new boundary with the given two boundaries.
+ *
+ * @param b1 one boundary
+ * @param b2 the other boundary
+ * @return An optional with a new boundary or an empty optional, if the creation fails.
+ */
Optional<T> create(T b1, T b2);
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreaterType.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreaterType.java
index 60289a0e..b83049ef 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreaterType.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/BoundaryBiCreaterType.java
@@ -1,10 +1,34 @@
package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
public enum BoundaryBiCreaterType {
+ /**
+ * Type, that indicates, that the creater should create a new boundary, which is the intersection
+ * of the two boundaries.
+ */
INTERSECTION,
+ /**
+ * Type, that indicates, that the creater should create a new boundary with the lower bounds of
+ * both boundaries.
+ */
LOWER_BOUNDS,
+ /**
+ * Type, that indicates, that the creater should create a new boundary with the upper bounds of
+ * both boundaries.
+ */
UPPER_BOUNDS,
+ /**
+ * Type, that indicates, that the creater should create a new boundary, which is between the both
+ * boundaries.
+ */
BETWEEN,
+ /**
+ * Type, that indicates, that the creater should create a new boundary, which is a combination of
+ * the both boundaries. However, both boundaries are not in contact.
+ */
APPEND,
- COMBINE;
+ /**
+ * Type, that indicates, that the creater should create a new boundary, which is a combination of
+ * the both boundaries. Both boundaries can be in contact. (UNION)
+ */
+ COMBINE
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/EmptyBiCreater.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/EmptyBiCreater.java
index e3251828..2eb770dd 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/EmptyBiCreater.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/bicreater/EmptyBiCreater.java
@@ -3,6 +3,9 @@ package de.unikoblenz.fgbks.base.utils.boundary.bicreater;
import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
import java.util.Optional;
+/**
+ * The empty bi creater returns always an empty optional.
+ */
public class EmptyBiCreater extends AbstractBoundaryBiCreater<Boundary> {
private static final EmptyBiCreater instance = new EmptyBiCreater();
@@ -11,6 +14,11 @@ public class EmptyBiCreater extends AbstractBoundaryBiCreater<Boundary> {
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static EmptyBiCreater getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheck.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheck.java
index 3ba0854d..c497b4f3 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheck.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheck.java
@@ -2,9 +2,27 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
+/**
+ * The checker interface. Used to check something between two boundaries, specified by the {@link
+ * BoundaryCheckType}.
+ *
+ * @param <T> the boundary type
+ */
public interface BoundaryCheck<T extends Boundary> {
+ /**
+ * Get the {@link BoundaryCheckType}.
+ *
+ * @return the {@link BoundaryCheckType}
+ */
BoundaryCheckType getType();
+ /**
+ * Perform the check between the two boundaries.
+ *
+ * @param b1 one boundary
+ * @param b2 the other boundary
+ * @return true, if the check return true.
+ */
boolean check(T b1, T b2);
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheckType.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheckType.java
index d6d849ab..c85b15e9 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheckType.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/BoundaryCheckType.java
@@ -1,10 +1,34 @@
package de.unikoblenz.fgbks.base.utils.boundary.checker;
public enum BoundaryCheckType {
+ /**
+ * Type, that indicates, that the checker should check, if one boundary is equal to the other
+ * boundary.
+ */
IS_EQUAL,
+ /**
+ * Type, that indicates, that the checker should check, if one boundary subsumes the other
+ * boundary or the other boundary subsumes the first boundary.
+ */
IS_SUBSUMPTION,
+ /**
+ * Type, that indicates, that the checker should check, if one boundary subsumes the other
+ * boundary.
+ */
SUBSUMES,
+ /**
+ * Type, that indicates, that the checker should check, if one boundary is in contact to the other
+ * boundary.
+ */
IS_IN_CONTACT,
+ /**
+ * Type, that indicates, that the checker should check, if one boundary is not in contact to the
+ * other boundary.
+ */
IS_NOT_IN_CONTACT,
- IS_OVERLAPPING;
+ /**
+ * Type, that indicates, that the checker should check, if one boundary is overlapping with the
+ * other boundary.
+ */
+ IS_OVERLAPPING
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckEqual.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckEqual.java
index fe5c2ac2..1f2f7791 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckEqual.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckEqual.java
@@ -2,6 +2,17 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
+/**
+ * The equal checker implementation of {@link BoundaryCheckType#IS_EQUAL} for {@link
+ * AbstractGrowingBoundary}. <br> The check returns true, if the first boundary is equal to the
+ * other boundary. <br> E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "= 1"; b2 = "= 1" -> true
+ * <li>b1 = "<= 1"; b2 = "< 2" -> true (Integer or Long) / false (others)
+ * <li>b1 = "[0..20]"; b2 = "[4..22]" -> false
+ * </ul>
+ */
public class CheckEqual extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
private static final CheckEqual instance = new CheckEqual();
@@ -10,6 +21,11 @@ public class CheckEqual extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckEqual getInstance() {
return instance;
}
@@ -24,6 +40,7 @@ public class CheckEqual extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
return checkEqual(b1, b2);
}
+ /** see {@link CheckEqual} */
public static boolean checkEqual(AbstractGrowingBoundary b1, AbstractGrowingBoundary b2) {
if (b1 == b2) {
return true;
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckInContact.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckInContact.java
index c2a3fa79..bcb74f14 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckInContact.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckInContact.java
@@ -4,6 +4,19 @@ import static de.unikoblenz.fgbks.base.utils.boundary.BoundType.INCLUSIVE;
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
+/**
+ * The in contact checker implementation of {@link BoundaryCheckType#IS_IN_CONTACT} for {@link
+ * AbstractGrowingBoundary}. <br> The check returns true, if the first boundary is in contact with
+ * the other boundary.
+ * <br>
+ * E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "= 1"; b2 = "= 1" -> true
+ * <li>b1 = "<= 1"; b2 = "< 2" -> true
+ * <li>b1 = "[0..20]"; b2 = "]20..22]" -> false
+ * </ul>
+ */
public class CheckInContact extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
private static final CheckInContact instance = new CheckInContact();
@@ -12,6 +25,11 @@ public class CheckInContact extends AbstractBoundaryCheck<AbstractGrowingBoundar
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckInContact getInstance() {
return instance;
}
@@ -26,6 +44,9 @@ public class CheckInContact extends AbstractBoundaryCheck<AbstractGrowingBoundar
return checkInContact(b1, b2);
}
+ /**
+ * see {@link CheckInContact}
+ */
public static boolean checkInContact(AbstractGrowingBoundary b1, AbstractGrowingBoundary b2) {
// TODO: check raw types
if (b1.getLowerBound().compareTo(b2.getLowerBound()) <= 0) {
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckIsSubsumption.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckIsSubsumption.java
index 435747b3..08693638 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckIsSubsumption.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckIsSubsumption.java
@@ -2,6 +2,19 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
+/**
+ * The subsumes checker implementation of {@link BoundaryCheckType#IS_SUBSUMPTION} for {@link
+ * AbstractGrowingBoundary}. <br> The check returns true, if the first boundary completely subsumes
+ * (not equal) the other boundary or the other way around.
+ * <br>
+ * E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "[0..20]"; b2 = "[4..19]" -> true
+ * <li>b1 = "[4..19]"; b2 = "[1..19]" -> true
+ * <li>b1 = "[0..20]"; b2 = "[4..22]" -> false
+ * </ul>
+ */
public class CheckIsSubsumption extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
private static final CheckIsSubsumption instance = new CheckIsSubsumption();
@@ -10,6 +23,11 @@ public class CheckIsSubsumption extends AbstractBoundaryCheck<AbstractGrowingBou
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckIsSubsumption getInstance() {
return instance;
}
@@ -24,6 +42,9 @@ public class CheckIsSubsumption extends AbstractBoundaryCheck<AbstractGrowingBou
return checkIsSubsumption(b1, b2);
}
+ /**
+ * see {@link CheckIsSubsumption}
+ */
public static boolean checkIsSubsumption(AbstractGrowingBoundary b1, AbstractGrowingBoundary b2) {
return CheckSubsumes.checkSubsumes(b1, b2) || CheckSubsumes.checkSubsumes(b2, b1);
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckNotInContact.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckNotInContact.java
index 21033ba9..3f8a787e 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckNotInContact.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckNotInContact.java
@@ -2,6 +2,17 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
+/**
+ * The not in contact checker implementation of {@link BoundaryCheckType#IS_NOT_IN_CONTACT} for
+ * {@link AbstractGrowingBoundary}. <br> The check returns true, if the first boundary is not in
+ * contact with the other boundary. <br> E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "= 1"; b2 = "= 1" -> false
+ * <li>b1 = "<= 1"; b2 = "< 2" -> false
+ * <li>b1 = "[0..20]"; b2 = "]20..22]" -> true
+ * </ul>
+ */
public class CheckNotInContact extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
private static final CheckNotInContact instance = new CheckNotInContact();
@@ -10,6 +21,11 @@ public class CheckNotInContact extends AbstractBoundaryCheck<AbstractGrowingBoun
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckNotInContact getInstance() {
return instance;
}
@@ -23,4 +39,11 @@ public class CheckNotInContact extends AbstractBoundaryCheck<AbstractGrowingBoun
public boolean check(AbstractGrowingBoundary b1, AbstractGrowingBoundary b2) {
return !CheckInContact.checkInContact(b1, b2);
}
+
+ /**
+ * see {@link CheckNotInContact}
+ */
+ public static boolean checkNotInContact(AbstractGrowingBoundary b1, AbstractGrowingBoundary b2) {
+ return !CheckInContact.checkInContact(b1, b2);
+ }
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckOverlap.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckOverlap.java
index 380531ba..0b5639ea 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckOverlap.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckOverlap.java
@@ -2,6 +2,17 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
+/**
+ * The overlap checker implementation of {@link BoundaryCheckType#IS_OVERLAPPING} for {@link
+ * AbstractGrowingBoundary}. <br> The check returns true, if the first boundary is overlapping the
+ * other boundary (not equal and no subsumption). <br> E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "<= 1"; b2 = ">= 0" -> true
+ * <li>b1 = "<= 1"; b2 = "< 2" -> false (for integer/long) / true for double
+ * <li>b1 = "[0..20]"; b2 = "[4..22]" -> true
+ * </ul>
+ */
public class CheckOverlap extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
private static final CheckOverlap instance = new CheckOverlap();
@@ -10,6 +21,11 @@ public class CheckOverlap extends AbstractBoundaryCheck<AbstractGrowingBoundary>
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckOverlap getInstance() {
return instance;
}
@@ -24,6 +40,7 @@ public class CheckOverlap extends AbstractBoundaryCheck<AbstractGrowingBoundary>
return checkOverlapping(b1, b2);
}
+ /** see {@link CheckOverlap} */
public static boolean checkOverlapping(AbstractGrowingBoundary b1, AbstractGrowingBoundary b2) {
return CheckInContact.checkInContact(b1, b2)
&& !CheckEqual.checkEqual(b1, b2)
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringEqual.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringEqual.java
index 6bda6074..24b85844 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringEqual.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringEqual.java
@@ -2,6 +2,17 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+/**
+ * The equal checker implementation of {@link BoundaryCheckType#IS_EQUAL} for {@link
+ * StringBoundary}. <br> The check returns true, if the first boundary is equal to the other
+ * boundary. <br> E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "a"; b2 = "a" -> true
+ * <li>b1 = "not("a","b"); b2 = "not("a","b")" -> true
+ * <li>b1 = "a","b"; b2 = "a" -> false
+ * </ul>
+ */
public class CheckStringEqual extends AbstractBoundaryCheck<StringBoundary> {
private static CheckStringEqual instance = new CheckStringEqual();
@@ -10,6 +21,11 @@ public class CheckStringEqual extends AbstractBoundaryCheck<StringBoundary> {
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckStringEqual getInstance() {
return instance;
}
@@ -24,6 +40,7 @@ public class CheckStringEqual extends AbstractBoundaryCheck<StringBoundary> {
return checkEqual(b1, b2);
}
+ /** see {@link CheckStringEqual} */
public static boolean checkEqual(StringBoundary b1, StringBoundary b2) {
if (b1 == b2 || b1.getText().equals(b2.getText()) || b1.matchesAny() && b2.matchesAny()) {
return true;
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringInContact.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringInContact.java
index f4f1b172..3dc1cdd1 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringInContact.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringInContact.java
@@ -2,6 +2,17 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+/**
+ * The in contact checker implementation of {@link BoundaryCheckType#IS_IN_CONTACT} for {@link
+ * StringBoundary}. <br> The check returns true, if the first boundary is in contact with the other
+ * boundary. <br> E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "a"; b2 = "a" -> true
+ * <li>b1 = "not("a","b"); b2 = "not("a","b")" -> true
+ * <li>b1 = "a","b"; b2 = "c" -> false
+ * </ul>
+ */
public class CheckStringInContact extends AbstractBoundaryCheck<StringBoundary> {
private static CheckStringInContact instance = new CheckStringInContact();
@@ -10,6 +21,11 @@ public class CheckStringInContact extends AbstractBoundaryCheck<StringBoundary>
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckStringInContact getInstance() {
return instance;
}
@@ -23,7 +39,7 @@ public class CheckStringInContact extends AbstractBoundaryCheck<StringBoundary>
public boolean check(StringBoundary b1, StringBoundary b2) {
return checkInContact(b1, b2);
}
-
+ /** see {@link CheckStringInContact} */
public static boolean checkInContact(StringBoundary b1, StringBoundary b2) {
if (b1.matchesAny()
|| b2.matchesAny()
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringNotInContact.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringNotInContact.java
index 2bc266af..6d0abf77 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringNotInContact.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringNotInContact.java
@@ -2,6 +2,17 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+/**
+ * The not in contact checker implementation of {@link BoundaryCheckType#IS_NOT_IN_CONTACT} for
+ * {@link StringBoundary}. <br> The check returns true, if the first boundary is not in contact with
+ * the other boundary. <br> E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "a"; b2 = "a" -> false
+ * <li>b1 = "not("a","b"); b2 = "not("a","b")" -> false
+ * <li>b1 = "a","b"; b2 = "c" -> true
+ * </ul>
+ */
public class CheckStringNotInContact extends AbstractBoundaryCheck<StringBoundary> {
private static CheckStringNotInContact instance = new CheckStringNotInContact();
@@ -10,6 +21,11 @@ public class CheckStringNotInContact extends AbstractBoundaryCheck<StringBoundar
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckStringNotInContact getInstance() {
return instance;
}
@@ -23,7 +39,7 @@ public class CheckStringNotInContact extends AbstractBoundaryCheck<StringBoundar
public boolean check(StringBoundary b1, StringBoundary b2) {
return checkNotInContact(b1, b2);
}
-
+ /** see {@link CheckStringNotInContact} */
public static boolean checkNotInContact(StringBoundary b1, StringBoundary b2) {
return !CheckStringInContact.checkInContact(b1, b2);
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringOverlap.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringOverlap.java
index 954d82be..9e4116f6 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringOverlap.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringOverlap.java
@@ -2,6 +2,17 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+/**
+ * The overlap checker implementation of {@link BoundaryCheckType#IS_OVERLAPPING} for {@link
+ * StringBoundary}. <br> The check returns true, if the first boundary is overlapping with the other
+ * boundary (not equal and no subsumption). <br> E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "a"; b2 = "a" -> false
+ * <li>b1 = "not("a","b"); b2 = "not("a","b")" -> false
+ * <li>b1 = "a","b"; b2 = "b" -> true
+ * </ul>
+ */
public class CheckStringOverlap extends AbstractBoundaryCheck<StringBoundary> {
private static CheckStringOverlap instance = new CheckStringOverlap();
@@ -10,6 +21,11 @@ public class CheckStringOverlap extends AbstractBoundaryCheck<StringBoundary> {
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckStringOverlap getInstance() {
return instance;
}
@@ -24,6 +40,7 @@ public class CheckStringOverlap extends AbstractBoundaryCheck<StringBoundary> {
return checkSubsumption(b1, b2);
}
+ /** see {@link CheckStringOverlap} */
public static boolean checkSubsumption(StringBoundary b1, StringBoundary b2) {
return CheckStringInContact.checkInContact(b1, b2)
&& !CheckStringEqual.checkEqual(b1, b2)
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumes.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumes.java
index 14f773f2..fe3720f0 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumes.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumes.java
@@ -2,6 +2,18 @@ package de.unikoblenz.fgbks.base.utils.boundary.checker;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
+/**
+ * The subsumes checker implementation of {@link BoundaryCheckType#SUBSUMES} for {@link
+ * StringBoundary}. <br> The check returns true, if the first boundary completely subsumes (not
+ * equal) the other boundary.
+ * <br>
+ * E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "a","b"; b2 = "a" -> true
+ * <li>b1 = "a"; b2 = "b" -> false
+ * </ul>
+ */
public class CheckStringSubsumes extends AbstractBoundaryCheck<StringBoundary> {
private static CheckStringSubsumes instance = new CheckStringSubsumes();
@@ -10,6 +22,11 @@ public class CheckStringSubsumes extends AbstractBoundaryCheck<StringBoundary> {
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckStringSubsumes getInstance() {
return instance;
}
@@ -24,6 +41,9 @@ public class CheckStringSubsumes extends AbstractBoundaryCheck<StringBoundary> {
return checkSubsumes(b1, b2);
}
+ /**
+ * see {@link CheckStringSubsumes}
+ */
public static boolean checkSubsumes(StringBoundary b1, StringBoundary b2) {
if (b1.matchesAny() && !b2.matchesAny()) {
return true;
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumption.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumption.java
index 6ab3e072..acd1b932 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumption.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckStringSubsumption.java
@@ -10,6 +10,11 @@ public class CheckStringSubsumption extends AbstractBoundaryCheck<StringBoundary
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckStringSubsumption getInstance() {
return instance;
}
@@ -24,6 +29,9 @@ public class CheckStringSubsumption extends AbstractBoundaryCheck<StringBoundary
return checkSubsumption(b1, b2);
}
+ /**
+ * see {@link CheckStringSubsumption}
+ */
public static boolean checkSubsumption(StringBoundary b1, StringBoundary b2) {
return CheckStringSubsumes.checkSubsumes(b1, b2) || CheckStringSubsumes.checkSubsumes(b2, b1);
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckSubsumes.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckSubsumes.java
index 4ee2b429..5e74a3da 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckSubsumes.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/checker/CheckSubsumes.java
@@ -5,6 +5,19 @@ import static de.unikoblenz.fgbks.base.utils.boundary.BoundType.INCLUSIVE;
import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
+/**
+ * The subsumes checker implementation of {@link BoundaryCheckType#SUBSUMES} for {@link
+ * AbstractGrowingBoundary}. <br> The check returns true, if the first boundary completely subsumes
+ * (not equal) the other boundary.
+ * <br>
+ * E.g: <br>
+ *
+ * <ul>
+ * <li>b1 = "[0..20]"; b2 = "[4..19]" -> true
+ * <li>b1 = "[4..19]"; b2 = "[1..19]" -> false
+ * <li>b1 = "[0..20]"; b2 = "[4..22]" -> false
+ * </ul>
+ */
public class CheckSubsumes extends AbstractBoundaryCheck<AbstractGrowingBoundary> {
private static final CheckSubsumes instance = new CheckSubsumes();
@@ -13,6 +26,11 @@ public class CheckSubsumes extends AbstractBoundaryCheck<AbstractGrowingBoundary
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CheckSubsumes getInstance() {
return instance;
}
@@ -27,6 +45,9 @@ public class CheckSubsumes extends AbstractBoundaryCheck<AbstractGrowingBoundary
return checkSubsumes(b1, b2);
}
+ /**
+ * see {@link CheckSubsumes}
+ */
public static boolean checkSubsumes(AbstractGrowingBoundary b1, AbstractGrowingBoundary b2) {
// TODO: check raw types
int compLo = b1.getLowerBound().compareTo(b2.getLowerBound());
@@ -37,20 +58,18 @@ public class CheckSubsumes extends AbstractBoundaryCheck<AbstractGrowingBoundary
if (compLo > 0
|| compUp < 0
|| (compLo == 0
- && b1.getLowerBoundType() == EXCLUSIVE
- && b2.getLowerBoundType() == INCLUSIVE)
+ && b1.getLowerBoundType() == EXCLUSIVE
+ && b2.getLowerBoundType() == INCLUSIVE)
|| (compUp == 0
- && b1.getUpperBoundType() == EXCLUSIVE
- && b2.getUpperBoundType() == INCLUSIVE)) {
+ && b1.getUpperBoundType() == EXCLUSIVE
+ && b2.getUpperBoundType() == INCLUSIVE)) {
return false;
}
if (compLo == 0 && b1.getLowerBoundType() != b2.getLowerBoundType()
|| compUp == 0 && b1.getUpperBoundType() != b2.getUpperBoundType()) {
return true;
- } else if ((compLo + compUp) == 0) {
- return false;
} else {
- return true;
+ return (compLo + compUp) != 0;
}
}
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreater.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreater.java
index 112582c2..e2d14c0d 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreater.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreater.java
@@ -3,9 +3,26 @@ package de.unikoblenz.fgbks.base.utils.boundary.creater;
import de.unikoblenz.fgbks.base.utils.boundary.Boundary;
import java.util.Optional;
+/**
+ * The creater interface. Used to create a new Boundary of a given one with a modification,
+ * specified by the {@link BoundaryCreaterType}.
+ *
+ * @param <T> the boundary type
+ */
public interface BoundaryCreater<T extends Boundary> {
+ /**
+ * Get the {@link BoundaryCreaterType}.
+ *
+ * @return the {@link BoundaryCreaterType}
+ */
BoundaryCreaterType getType();
+ /**
+ * Perform the creation of a new boundary with the given boundary.
+ *
+ * @param b the boundary
+ * @return An optional with a new boundary or an empty optional, if the creation fails.
+ */
Optional<T> create(T b);
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreaterType.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreaterType.java
index f240c05b..90566c83 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreaterType.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/BoundaryCreaterType.java
@@ -1,6 +1,14 @@
package de.unikoblenz.fgbks.base.utils.boundary.creater;
public enum BoundaryCreaterType {
+ /**
+ * Type, that indicates, that the creator should build a new boundary, which is lower than the
+ * current boundary.
+ */
LOWER,
- UPPER;
+ /**
+ * Type, that indicates, that the creator should build a new boundary, which is higher than the
+ * current boundary.
+ */
+ UPPER
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterLower.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterLower.java
index ce669e9f..4562f00d 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterLower.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterLower.java
@@ -4,6 +4,11 @@ import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
import de.unikoblenz.fgbks.base.utils.boundary.BoundType;
import java.util.Optional;
+/**
+ * The upper creator implementation of {@link BoundaryCreaterType#LOWER} for {@link
+ * AbstractGrowingBoundary}. <br> The result is the complete range of values, which are lower than
+ * the current boundary.<br> In: {@code >5} <br> Out: {@code <=5} <br>
+ */
public class CreaterLower extends AbstractBoundaryCreater<AbstractGrowingBoundary> {
private static final CreaterLower instance = new CreaterLower();
@@ -12,6 +17,11 @@ public class CreaterLower extends AbstractBoundaryCreater<AbstractGrowingBoundar
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CreaterLower getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringLower.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringLower.java
index 6543901a..9c372d6d 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringLower.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringLower.java
@@ -3,6 +3,12 @@ package de.unikoblenz.fgbks.base.utils.boundary.creater;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
import java.util.Optional;
+/**
+ * The upper creator implementation of {@link BoundaryCreaterType#LOWER} for {@link
+ * StringBoundary}.
+ * <br>
+ * The result is the set of all strings which are NOT the current StringBoundary.
+ */
public class CreaterStringLower extends AbstractBoundaryCreater<StringBoundary> {
private static final CreaterStringLower instance = new CreaterStringLower();
@@ -11,6 +17,11 @@ public class CreaterStringLower extends AbstractBoundaryCreater<StringBoundary>
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CreaterStringLower getInstance() {
return instance;
}
@@ -22,10 +33,11 @@ public class CreaterStringLower extends AbstractBoundaryCreater<StringBoundary>
@Override
public Optional<StringBoundary> create(StringBoundary b) {
- return Optional.of(StringBoundary.getBuilder()
- .addValues(b.getValues())
- .matchesNoneOfValues(!b.matchesNoneOfValues())
- .matchesAny(b.getAmountOfElements() == 0)
- .build());
+ return Optional.of(
+ StringBoundary.getBuilder()
+ .addValues(b.getValues())
+ .matchesNoneOfValues(!b.matchesNoneOfValues())
+ .matchesAny(b.getAmountOfElements() == 0)
+ .build());
}
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringUpper.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringUpper.java
index 00e08a00..90876e21 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringUpper.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterStringUpper.java
@@ -3,6 +3,13 @@ package de.unikoblenz.fgbks.base.utils.boundary.creater;
import de.unikoblenz.fgbks.base.utils.boundary.impl.StringBoundary;
import java.util.Optional;
+/**
+ * The upper creator implementation of {@link BoundaryCreaterType#UPPER} for {@link
+ * StringBoundary}.
+ * <br>
+ * For the String creater this result is always empty. Use {@link BoundaryCreaterType#LOWER} and
+ * {@link CreaterStringLower}.
+ */
public class CreaterStringUpper extends AbstractBoundaryCreater<StringBoundary> {
private static final CreaterStringUpper instance = new CreaterStringUpper();
@@ -11,6 +18,11 @@ public class CreaterStringUpper extends AbstractBoundaryCreater<StringBoundary>
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CreaterStringUpper getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterUpper.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterUpper.java
index 8fe0b3ca..180835e4 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterUpper.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/CreaterUpper.java
@@ -4,6 +4,11 @@ import de.unikoblenz.fgbks.base.utils.boundary.AbstractGrowingBoundary;
import de.unikoblenz.fgbks.base.utils.boundary.BoundType;
import java.util.Optional;
+/**
+ * The upper creator implementation of {@link BoundaryCreaterType#UPPER} for {@link
+ * AbstractGrowingBoundary}. <br> The result is the complete range of values, which are higher than
+ * the current boundary.<br> In: {@code <=5} <br> Out: {@code >5} <br>
+ */
public class CreaterUpper extends AbstractBoundaryCreater<AbstractGrowingBoundary> {
private static final CreaterUpper instance = new CreaterUpper();
@@ -12,6 +17,11 @@ public class CreaterUpper extends AbstractBoundaryCreater<AbstractGrowingBoundar
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static CreaterUpper getInstance() {
return instance;
}
diff --git a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/EmptyCreater.java b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/EmptyCreater.java
index eeec9f3d..e742689b 100644
--- a/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/EmptyCreater.java
+++ b/dmnverifierapi/src/main/java/de/unikoblenz/fgbks/base/utils/boundary/creater/EmptyCreater.java
@@ -11,6 +11,11 @@ public class EmptyCreater extends AbstractBoundaryCreater<Boundary> {
super();
}
+ /**
+ * Get the current instance of this class.
+ *
+ * @return the singleton instance
+ */
public static EmptyCreater getInstance() {
return instance;
}
--
GitLab