/** * 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()); }