/**
* liefert eine neue Lücke zwischen this und other
*
* @param other die zweite Lücke
* @return eine neue Lücke zwischen this und other null, wenn die Lücken überlappen oder angrenzen
*/
public Gap between(Gap other) {
// if (other.start > this.end) {
// return (new Gap(this.end, other.start));
// } else {
// return null;
// }
if (this.overlaps(other) || this.touches(other)) return null;
return new Gap(
this.end < other.getStart() ? this.end : other.end,
this.start > other.getEnd() ? this.start : other.start);
}
/**
* prüft, ob this other komplett enthält oder gleich ist
*
* @param other Lücke, die möglicherweise enthalten ist
* @return true, wenn this other komplett enthält oder gleiche Grenzen hat, sonst false
*/
public boolean contains(Gap other) {
return (this.end == other.getEnd() || this.contains(other.getEnd()))
&& this.contains(other.getStart());
}
/**
* Testen der enthaltenen Routinen per Assert Notwendig ist, das Projekt mit "Enable Assertions"
* zu kompilieren.
*
* @param args
*/
public static void main(String[] args) {
Gap gap = new Gap(10, 20);
assert gap.precedes(new Gap(30, 40));
assert gap.precedes(new Gap(20, 40));
assert !gap.precedes(new Gap(15, 40));
assert gap.succeeds(new Gap(0, 5));
assert gap.succeeds(new Gap(0, 10));
// assert gap.succeeds(new Gap(0, 11));
assert !gap.succeeds(new Gap(0, 11));
assert gap.touches(new Gap(0, 10));
assert gap.touches(new Gap(20, 30));
assert !gap.touches(new Gap(0, 11));
assert !gap.touches(new Gap(19, 20));
assert !gap.touches(new Gap(21, 25));
assert gap.contains(15);
assert gap.contains(10);
assert !gap.contains(22);
assert !gap.contains(20);
assert gap.contains(new Gap(15, 16));
assert gap.contains(new Gap(10, 16));
assert gap.contains(new Gap(15, 20));
assert !gap.contains(new Gap(9, 15));
assert !gap.contains(new Gap(15, 21));
assert gap.overlaps(new Gap(8, 12));
assert gap.overlaps(new Gap(18, 22));
assert !gap.overlaps(new Gap(8, 9));
assert !gap.overlaps(new Gap(22, 25));
assert !gap.overlaps(new Gap(20, 25));
assert gap.overlaps(new Gap(8, 25));
assert gap.overlaps(new Gap(12, 18));
assert " 10.. 20".equals(gap.toString());
assert " 0.. 20".equals((new Gap(0, 20)).toString());
assert " 0.. 2".equals((new Gap(0, 2)).toString());
assert "100..200".equals((new Gap(100, 200)).toString());
assert gap.equals(new Gap(10, 20));
assert !gap.equals(new Gap(1, 20));
Gap testGap = null;
assert !gap.equals(testGap) : "equals mit null";
assert !gap.equals("String") : "equals mit falschem Objekttyp";
assert (new Gap(0, 20)).equals(gap.union(new Gap(0, 10)))
: "Vereinigung mit links angrenzender Lücke";
assert gap != gap.union(new Gap(0, 10)) : "Vereinigung muss neues Element zurückgeben";
assert (new Gap(10, 30)).equals(gap.union(new Gap(20, 30)))
: "Vereinigung mit rechts angrenzender Lücke";
assert (new Gap(5, 20)).equals(gap.union(new Gap(5, 15)))
: "Vereinigung mit links überlappender Lücke";
assert (new Gap(10, 25)).equals(gap.union(new Gap(15, 25)))
: "Vereinigung mit rechts überlappender Lücke";
assert null == (gap.union(new Gap(0, 5))) : "keine Vereinigung unabhängiger Lücken";
assert null == (gap.union(new Gap(25, 35))) : "keine Vereinigung unabhängiger Lücken";
assert (new Gap(5, 10)).equals(gap.between(new Gap(0, 5)));
assert (new Gap(20, 25)).equals(gap.between(new Gap(25, 30)));
assert null == (gap.between(new Gap(0, 10)));
assert null == (gap.between(new Gap(20, 30)));
assert null == (gap.between(new Gap(5, 15)));
assert null == (gap.between(new Gap(15, 25)));
assert 0 == gap.compareTo(new Gap(10, 20));
assert -1 == gap.compareTo(new Gap(30, 40));
assert -1 == gap.compareTo(new Gap(11, 15));
assert 1 == gap.compareTo(new Gap(0, 5));
assert 1 == gap.compareTo(new Gap(5, 10));
assert 1 == gap.compareTo(new Gap(9, 20));
// sub: zieht other aus der aktuellen Lücke ab (weil ein Auto abgestellt wird).
// Ist other gleich this, so wird ein leeres Array zurückgegeben.
Gap[] sub = gap.sub(new Gap(10, 20));
assert 0 == sub.length : "sub gleiche Lücke ergibt kein leeres Array";
// keinerlei Zusammenhang muss Element wie this zurückliefern
sub = gap.sub(new Gap(0, 5));
assert 1 == sub.length : "sub ohne Überlagerung darf nur ein Array mit einem Element liefern";
assert gap.equals(sub[0]) : "sub ohne Überlagerung soll Array mit this zurückliefern";
sub = gap.sub(new Gap(25, 30));
assert 1 == sub.length : "sub ohne Überlagerung darf nur ein Array mit einem Element liefern";
assert gap.equals(sub[0]) : "sub ohne Überlagerung soll Array mit this zurückliefern";
// Überlappung geht außerhalb der eigenen Lücke -> muss Element wie this zurückliefern
sub = gap.sub(new Gap(5, 12));
assert 1 == sub.length : "sub bei Überlappung links darf das Array nur ein Element enthalten";
assert gap.equals(sub[0]) : "sub bei Überlappung links muss this zurückgeliefert werden";
sub = gap.sub(new Gap(18, 22));
assert 1 == sub.length : "sub bei Überlappung rechts darf das Array nur ein Element enthalten";
assert gap.equals(sub[0]) : "sub bei Überlappung rechts muss this zurückgeliefert werden";
// Ein Rand stimmt überein -> ein neues Element entsteht
sub = gap.sub(new Gap(18, 20));
assert 1 == sub.length : "sub rechter Rand gleich darf nur ein Array mit einem Element liefern";
assert (new Gap(10, 18)).equals(sub[0]) : "sub mit gleichem rechten Rand";
sub = gap.sub(new Gap(10, 12));
assert 1 == sub.length : "sub linker Rand gleich darf nur ein Array mit einem Element liefern";
assert (new Gap(12, 20)).equals(sub[0]) : "sub mit gleichem linken Rand";
// mittiges Abziehen -> zwei neue Elemente entstehen
sub = gap.sub(new Gap(12, 18));
assert 2 == sub.length : "sub mittig muss Array mit zwei Elementen liefern";
assert (new Gap(10, 12)).equals(sub[0]) : "sub mittig linkes Element falsch";
assert (new Gap(18, 20)).equals(sub[1]) : "sub mittig rechtes Element falsch";
System.out.println("Tests erfolgreich (oder Assertions off)");
}
/**
* prüft, ob this und other überlappen. Dafür muss this beginnen, bevor other endet und enden,
* nachdem other startet.
*
* @param other Lücke, die möglicherweise überlappt
* @return true, wenn this und other überlappen
*/
public boolean overlaps(Gap other) {
return (this.start < other.getEnd()) && (this.end > other.getStart());
}