Feat: Add Proxy classes

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/database/ProxyLoader.java

 package de.hft.stuttgart.citydoctor2.database;
 
+import de.hft.stuttgart.citydoctor2.datastructure.CityObject;
+import de.hft.stuttgart.citydoctor2.datastructure.Geometry;
 import de.hft.stuttgart.citydoctor2.datastructure.GmlId;
 import de.hft.stuttgart.citydoctor2.datastructure.LinearRing;
+import de.hft.stuttgart.citydoctor2.datastructure.Polygon;
 import org.apache.commons.lang3.NotImplementedException;
 
 public class ProxyLoader {
@@ -12,8 +15,18 @@ public class ProxyLoader {
         this.cache = cache;
     }
 
-    public LinearRing load(GmlId id){
+    public LinearRing loadRing(GmlId id){
 //        return cache.get(id);
         throw new NotImplementedException();
     }
+
+    public Polygon loadPolygon(GmlId id){
+        throw new NotImplementedException();
+    }
+
+    public Geometry loadGeometry(GmlId id){
+        throw new NotImplementedException();
+    }
+
+
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/GeometryProxy.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.CheckResult;
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
+import de.hft.stuttgart.citydoctor2.database.ProxyLoader;
+import de.hft.stuttgart.citydoctor2.math.Vector3d;
+import javafx.scene.paint.Color;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class GeometryProxy extends Geometry {
+
+    private GmlId referenceId;
+    private final ProxyLoader loader;
+
+
+    public GeometryProxy(Geometry geom, ProxyLoader loader) {
+        super(geom.getType(), geom.getLod(), geom.getOrientation());
+        this.referenceId = geom.getGmlId();
+        this.loader = loader;
+    }
+
+    @Override
+    public Set<LinearRing> getAdjacentRingsOfVertex(Vertex v) {
+        return loader.loadGeometry(referenceId).getAdjacentRingsOfVertex(v);
+    }
+
+    @Override
+    public Orientation getOrientation() {
+        return loader.loadGeometry(referenceId).getOrientation();
+    }
+
+    @Override
+    void setParent(CityObject parent) {
+        loader.loadGeometry(referenceId).setParent(parent);
+    }
+
+    @Override
+    public CityObject getParent() {
+        return loader.loadGeometry(referenceId).getParent();
+    }
+
+    @Override
+    public void setType(GeometryType type) {
+        loader.loadGeometry(referenceId).setType(type);
+    }
+
+    @Override
+    public GeometryType getType() {
+        return loader.loadGeometry(referenceId).getType();
+    }
+
+    @Override
+    public Lod getLod() {
+        return loader.loadGeometry(referenceId).getLod();
+    }
+
+    @Override
+    public List<Polygon> getPolygons() {
+        return loader.loadGeometry(referenceId).getPolygons();
+    }
+
+    @Override
+    public void addPolygon(Polygon cdPoly) {
+        loader.loadGeometry(referenceId).addPolygon(cdPoly);
+    }
+
+    @Override
+    public void updateEdges() {
+        loader.loadGeometry(referenceId).updateEdges();
+    }
+
+    @Override
+    void anonymize() {
+        loader.loadGeometry(referenceId).anonymize();
+    }
+
+    @Override
+    public Vector3d getCenter() {
+        return loader.loadGeometry(referenceId).getCenter();
+    }
+
+    @Override
+    public BoundingBox calculateBoundingBox() {
+        return loader.loadGeometry(referenceId).calculateBoundingBox();
+    }
+
+    @Override
+    public double calculateVolume() {
+        return loader.loadGeometry(referenceId).calculateVolume();
+    }
+
+    @Override
+    public void setValidated(boolean validated) {
+        loader.loadGeometry(referenceId).setValidated(validated);
+    }
+
+    @Override
+    public boolean isValidated() {
+        return loader.loadGeometry(referenceId).isValidated();
+    }
+
+    @Override
+    public void accept(CheckableVisitor c) {
+        loader.loadGeometry(referenceId).accept(c);
+    }
+
+    @Override
+    public String toString() {
+        return loader.loadGeometry(referenceId).toString();
+    }
+
+    @Override
+    public String getDisplayText() {
+        return loader.loadGeometry(referenceId).getDisplayText();
+    }
+
+    @Override
+    public List<Vertex> getVertices() {
+        return loader.loadGeometry(referenceId).getVertices();
+    }
+
+    @Override
+    public List<Edge> getEdges() {
+        return loader.loadGeometry(referenceId).getEdges();
+    }
+
+    @Override
+    public List<Edge> getEdgesAdjacentTo(Vertex v) {
+        return loader.loadGeometry(referenceId).getEdgesAdjacentTo(v);
+    }
+
+    @Override
+    public Edge getEdge(Vertex v1, Vertex v2) {
+        return loader.loadGeometry(referenceId).getEdge(v1, v2);
+    }
+
+    @Override
+    public void updateEdgesAndVertices() {
+        loader.loadGeometry(referenceId).updateEdgesAndVertices();
+    }
+
+    @Override
+    public void updateVertices() {
+        loader.loadGeometry(referenceId).updateVertices();
+    }
+
+    @Override
+    void removePolygon(Polygon p) {
+        loader.loadGeometry(referenceId).removePolygon(p);
+    }
+
+    @Override
+    public void replacePolygon(Polygon p, ConcretePolygon... polygons) {
+        loader.loadGeometry(referenceId).replacePolygon(p, polygons);
+    }
+
+    @Override
+    public List<Edge> getEdgesAdjacentTo(Polygon p) {
+        return loader.loadGeometry(referenceId).getEdgesAdjacentTo(p);
+    }
+
+    @Override
+    public boolean containsPolygon(Polygon other) {
+        return loader.loadGeometry(referenceId).containsPolygon(other);
+    }
+
+    @Override
+    public void clearMetaData() {
+        loader.loadGeometry(referenceId).clearMetaData();
+    }
+
+    @Override
+    public Color getRenderColor() {
+        return loader.loadGeometry(referenceId).getRenderColor();
+    }
+
+    @Override
+    public void setGmlId(GmlId id) {
+        loader.loadGeometry(referenceId).setGmlId(id);
+        this.referenceId = id;
+    }
+
+    @Override
+    public GmlId getGmlId() {
+        return referenceId;
+    }
+
+    @Override
+    public void prepareForChecking() {
+        loader.loadGeometry(referenceId).prepareForChecking();
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        loader.loadGeometry(referenceId).clearMetaInformation();
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+        return loader.loadGeometry(referenceId).containsError(checkIdentifier);
+    }
+
+    @Override
+    public boolean hasError(CheckId checkIdentifier) {
+       return loader.loadGeometry(referenceId).hasError(checkIdentifier);
+    }
+
+    @Override
+    public CheckResult getCheckResult(CheckId id) {
+        return loader.loadGeometry(referenceId).getCheckResult(id);
+    }
+
+    @Override
+    public CheckResult getCheckResult(Check c) {
+       return loader.loadGeometry(referenceId).getCheckResult(c);
+    }
+
+    @Override
+    public Map<CheckId, CheckResult> getAllCheckResults() {
+        return loader.loadGeometry(referenceId).getAllCheckResults();
+    }
+
+    @Override
+    public boolean hasDependencyNotMetError(CheckId id) {
+        return loader.loadGeometry(referenceId).hasDependencyNotMetError(id);
+    }
+
+    @Override
+    public boolean hasAnyErrorWithoutDependencies() {
+        return loader.loadGeometry(referenceId).hasAnyErrorWithoutDependencies();
+    }
+
+    @Override
+    public boolean hasCheckResults() {
+        return loader.loadGeometry(referenceId).hasCheckResults();
+    }
+
+    @Override
+    public void addCheckResult(CheckResult cr) {
+        loader.loadGeometry(referenceId).addCheckResult(cr);
+    }
+
+    @Override
+    public void clearCheckResults() {
+        loader.loadGeometry(referenceId).clearCheckResults();
+    }
+
+    @Override
+    public boolean hasAnyError() {
+        return loader.loadGeometry(referenceId).hasAnyError();
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        loader.loadGeometry(referenceId).collectContainedErrors(errors);
+    }
+
+    @Override
+    public void collectErrors(List<CheckError> errors) {
+        loader.loadGeometry(referenceId).collectErrors(errors);
+    }
+
+    @Override
+    public Class<? extends Checkable> getCheckClass() {
+        return loader.loadGeometry(referenceId).getCheckClass();
+    }
+
+    @Override
+    public boolean hasExistingGmlId() {
+        return loader.loadGeometry(referenceId).hasExistingGmlId();
+    }
+
+}

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/LinearRingProxy.java

@@ -27,183 +27,183 @@ public class LinearRingProxy extends AbstractLinearRing {
 
     @Override
     public void setGmlId(GmlId id) {
-        loader.load(referenceId).setGmlId(id);
+        loader.loadRing(referenceId).setGmlId(id);
         this.referenceId = id;
     }
 
     @Override
     public void setValidated(boolean validated) {
         super.setValidated(validated);
-        loader.load(referenceId).setValidated(validated);
+        loader.loadRing(referenceId).setValidated(validated);
     }
 
     @Override
     public void accept(CheckableVisitor c) {
-        loader.load(referenceId).accept(c);
+        loader.loadRing(referenceId).accept(c);
     }
 
     @Override
     public void prepareForChecking() {
-        loader.load(referenceId).prepareForChecking();
+        loader.loadRing(referenceId).prepareForChecking();
     }
 
     @Override
     public void clearMetaInformation() {
-        loader.load(referenceId).clearMetaInformation();
+        loader.loadRing(referenceId).clearMetaInformation();
     }
 
     @Override
     public boolean containsError(CheckId checkIdentifier) {
-        return loader.load(referenceId).containsError(checkIdentifier);
+        return loader.loadRing(referenceId).containsError(checkIdentifier);
     }
 
     @Override
     public boolean hasError(CheckId checkIdentifier) {
-        return loader.load(referenceId).hasError(checkIdentifier);
+        return loader.loadRing(referenceId).hasError(checkIdentifier);
     }
 
     @Override
     public CheckResult getCheckResult(CheckId id) {
-        return loader.load(referenceId).getCheckResult(id);
+        return loader.loadRing(referenceId).getCheckResult(id);
     }
 
     @Override
     public CheckResult getCheckResult(Check c) {
-        return loader.load(referenceId).getCheckResult(c);
+        return loader.loadRing(referenceId).getCheckResult(c);
     }
 
     @Override
     public Map<CheckId, CheckResult> getAllCheckResults() {
-        return loader.load(referenceId).getAllCheckResults();
+        return loader.loadRing(referenceId).getAllCheckResults();
     }
 
     @Override
     public boolean hasDependencyNotMetError(CheckId id) {
-        return loader.load(referenceId).hasDependencyNotMetError(id);
+        return loader.loadRing(referenceId).hasDependencyNotMetError(id);
     }
 
     @Override
     public boolean hasAnyErrorWithoutDependencies() {
-        return loader.load(referenceId).hasAnyErrorWithoutDependencies();
+        return loader.loadRing(referenceId).hasAnyErrorWithoutDependencies();
     }
 
     @Override
     public boolean hasCheckResults() {
-        return loader.load(referenceId).hasCheckResults();
+        return loader.loadRing(referenceId).hasCheckResults();
     }
 
     @Override
     public void addCheckResult(CheckResult cr) {
-        loader.load(referenceId).addCheckResult(cr);
+        loader.loadRing(referenceId).addCheckResult(cr);
     }
 
     @Override
     public void clearCheckResults() {
-        loader.load(referenceId).clearCheckResults();
+        loader.loadRing(referenceId).clearCheckResults();
     }
 
     @Override
     public boolean hasAnyError() {
-        return loader.load(referenceId).hasAnyError();
+        return loader.loadRing(referenceId).hasAnyError();
     }
 
     @Override
     public void collectContainedErrors(List<CheckError> errors) {
-        loader.load(referenceId).collectContainedErrors(errors);
+        loader.loadRing(referenceId).collectContainedErrors(errors);
     }
 
     @Override
     public void collectErrors(List<CheckError> errors) {
-        loader.load(referenceId).collectErrors(errors);
+        loader.loadRing(referenceId).collectErrors(errors);
     }
 
     @Override
     public Class<? extends Checkable> getCheckClass() {
-        return loader.load(referenceId).getCheckClass();
+        return loader.loadRing(referenceId).getCheckClass();
     }
 
     @Override
     public boolean isPointInside(Vector3d v) {
-        return loader.load(referenceId).isPointInside(v);
+        return loader.loadRing(referenceId).isPointInside(v);
     }
 
     @Override
     public UnitVector3d calculateNormalNormalized() {
-        return loader.load(referenceId).calculateNormalNormalized();
+        return loader.loadRing(referenceId).calculateNormalNormalized();
     }
 
     @Override
     public Vector3d calculateNormal() {
-        return loader.load(referenceId).calculateNormal();
+        return loader.loadRing(referenceId).calculateNormal();
     }
 
     @Override
     public double getArea() {
-        return loader.load(referenceId).getArea();
+        return loader.loadRing(referenceId).getArea();
     }
 
     @Override
     public void setParent(Polygon polygon) {
-        loader.load(referenceId).setParent(polygon);
+        loader.loadRing(referenceId).setParent(polygon);
     }
 
     @Override
     public Polygon getParent() {
-        return loader.load(referenceId).getParent();
+        return loader.loadRing(referenceId).getParent();
     }
 
     @Override
     public LinearRingType getType() {
-        return loader.load(referenceId).getType();
+        return loader.loadRing(referenceId).getType();
     }
 
     @Override
     public List<Vertex> getVertices() {
-        return loader.load(referenceId).getVertices();
+        return loader.loadRing(referenceId).getVertices();
     }
 
     @Override
     public void addVertex(Vertex v) {
-        loader.load(referenceId).addVertex(v);
+        loader.loadRing(referenceId).addVertex(v);
     }
 
     @Override
     public void addVertex(int i, Vertex v) {
-        loader.load(referenceId).addVertex(i, v);
+        loader.loadRing(referenceId).addVertex(i, v);
     }
 
     @Override
     public void setVertex(int i, Vertex v) {
-        loader.load(referenceId).setVertex(i, v);
+        loader.loadRing(referenceId).setVertex(i, v);
     }
 
     @Override
     public boolean isRingConnectedViaPoint(LinearRing other) {
-        return loader.load(referenceId).isRingConnectedViaPoint(other);
+        return loader.loadRing(referenceId).isRingConnectedViaPoint(other);
     }
 
     @Override
     public List<Ray> getEdgeRays() {
-        return loader.load(referenceId).getEdgeRays();
+        return loader.loadRing(referenceId).getEdgeRays();
     }
 
     @Override
     public boolean hasPointAsCorner(Vertex v) {
-        return loader.load(referenceId).hasPointAsCorner(v);
+        return loader.loadRing(referenceId).hasPointAsCorner(v);
     }
 
     @Override
     public void setType(LinearRingType type) {
-        loader.load(referenceId).setType(type);
+        loader.loadRing(referenceId).setType(type);
     }
 
     @Override
     public void addAllVertices(List<Vertex> extRing) {
-        loader.load(referenceId).addAllVertices(extRing);
+        loader.loadRing(referenceId).addAllVertices(extRing);
     }
 
     @Override
     public void prepareLowMemoryUsageMode() {
-        loader.load(referenceId).prepareLowMemoryUsageMode();
+        loader.loadRing(referenceId).prepareLowMemoryUsageMode();
     }
 }

CityDoctorParent/CityDoctorModel/src/main/java/de/hft/stuttgart/citydoctor2/datastructure/PolygonProxy.java

+package de.hft.stuttgart.citydoctor2.datastructure;
+
+import de.hft.stuttgart.citydoctor2.check.Check;
+import de.hft.stuttgart.citydoctor2.check.CheckError;
+import de.hft.stuttgart.citydoctor2.check.CheckId;
+import de.hft.stuttgart.citydoctor2.check.CheckResult;
+import de.hft.stuttgart.citydoctor2.check.Checkable;
+import de.hft.stuttgart.citydoctor2.check.CheckableVisitor;
+import de.hft.stuttgart.citydoctor2.database.ProxyLoader;
+import de.hft.stuttgart.citydoctor2.math.Vector3d;
+import de.hft.stuttgart.citydoctor2.tesselation.TesselatedPolygon;
+import javafx.scene.paint.Color;
+
+import java.util.List;
+import java.util.Map;
+
+public class PolygonProxy extends Polygon {
+
+    //TODO: Implement methods
+    private final ProxyLoader loader;
+    private GmlId referenceId;
+
+    PolygonProxy(Polygon polygon, ProxyLoader loader) {
+        this.loader = loader;
+        this.referenceId = polygon.getGmlId();
+    }
+
+
+    @Override
+    public Vector3d calculateNormalNormalized() {
+        return loader.loadPolygon(referenceId).calculateNormalNormalized();
+    }
+
+    @Override
+    public Vector3d calculateNormal() {
+        return loader.loadPolygon(referenceId).calculateNormal();
+    }
+
+    @Override
+    public TesselatedPolygon tesselate() {
+        return loader.loadPolygon(referenceId).tesselate();
+    }
+
+    @Override
+    public LinearRing getExteriorRing() {
+        return loader.loadPolygon(referenceId).getExteriorRing();
+    }
+
+    @Override
+    public List<LinearRing> getInnerRings() {
+        return loader.loadPolygon(referenceId).getInnerRings();
+    }
+
+    @Override
+    public boolean isPointInsideExteriorRing(Vector3d v) {
+        return loader.loadPolygon(referenceId).isPointInsideExteriorRing(v);
+    }
+
+    @Override
+    public Geometry getParent() {
+        return loader.loadPolygon(referenceId).getParent();
+    }
+
+    @Override
+    public void setParent(Geometry geometry) {
+        loader.loadPolygon(referenceId).setParent(geometry);
+    }
+
+    @Override
+    public void setExteriorRing(LinearRing extRing) {
+        loader.loadPolygon(referenceId).setExteriorRing(extRing);
+    }
+
+    @Override
+    public boolean isPolygonConnectedViaPoint(Polygon other) {
+        return loader.loadPolygon(referenceId).isPolygonConnectedViaPoint(other);
+    }
+
+    @Override
+    public void addInteriorRing(LinearRing inter) {
+        loader.loadPolygon(referenceId).addInteriorRing(inter);
+    }
+
+    @Override
+    public BoundarySurface getPartOfSurface() {
+        return loader.loadPolygon(referenceId).getPartOfSurface();
+    }
+
+    @Override
+    public void setPartOfSurface(BoundarySurface bs) {
+        loader.loadPolygon(referenceId).setPartOfSurface(bs);
+    }
+
+    @Override
+    public void removeInnerRing(LinearRing ring) {
+        loader.loadPolygon(referenceId).removeInnerRing(ring);
+    }
+
+    @Override
+    public void setPartOfInstallation(Installation bi) {
+        loader.loadPolygon(referenceId).setPartOfInstallation(bi);
+    }
+
+    @Override
+    public Installation getPartOfInstallation() {
+        return loader.loadPolygon(referenceId).getPartOfInstallation();
+    }
+
+    @Override
+    public boolean hasPointAsCorner(Vertex v) {
+        return loader.loadPolygon(referenceId).hasPointAsCorner(v);
+    }
+
+    @Override
+    public void removeRings() {
+        loader.loadPolygon(referenceId).removeRings();
+    }
+
+    @Override
+    public boolean isLinkedTo() {
+        return loader.loadPolygon(referenceId).isLinkedTo();
+    }
+
+    @Override
+    public boolean isLink() {
+        return loader.loadPolygon(referenceId).isLink();
+    }
+
+    @Override
+    public LinkedPolygon getLinkedFromPolygon() {
+        return loader.loadPolygon(referenceId).getLinkedFromPolygon();
+    }
+
+    @Override
+    void anonymize() {
+        loader.loadPolygon(referenceId).anonymize();
+    }
+
+    @Override
+    public ConcretePolygon getOriginal() {
+        return loader.loadPolygon(referenceId).getOriginal();
+    }
+
+    @Override
+    public void prepareLowMemoryUsageMode() {
+        loader.loadPolygon(referenceId).prepareLowMemoryUsageMode();
+    }
+
+    @Override
+    public void remove() {
+        loader.loadPolygon(referenceId).remove();
+    }
+
+    @Override
+    public double getArea() {
+        return loader.loadPolygon(referenceId).getArea();
+    }
+
+    @Override
+    public Color getRenderColor() {
+        return loader.loadPolygon(referenceId).getRenderColor();
+    }
+
+    @Override
+    public void setGmlId(GmlId id) {
+        loader.loadPolygon(referenceId).setGmlId(id);
+        this.referenceId = id;
+    }
+
+    @Override
+    public void setValidated(boolean validated) {
+        super.setValidated(validated);
+        loader.loadPolygon(referenceId).setValidated(validated);
+    }
+
+
+    @Override
+    public void accept(CheckableVisitor c) {
+        loader.loadPolygon(referenceId).accept(c);
+    }
+
+    @Override
+    public GmlId getGmlId() {
+        return referenceId;
+    }
+
+    @Override
+    public void prepareForChecking() {
+        loader.loadPolygon(referenceId).prepareForChecking();
+    }
+
+    @Override
+    public void clearMetaInformation() {
+        loader.loadPolygon(referenceId).clearMetaInformation();
+    }
+
+    @Override
+    public boolean containsError(CheckId checkIdentifier) {
+       return loader.loadPolygon(referenceId).containsError(checkIdentifier);
+    }
+
+    @Override
+    public boolean hasError(CheckId checkIdentifier) {
+        return loader.loadPolygon(referenceId).hasError(checkIdentifier);
+    }
+
+    @Override
+    public CheckResult getCheckResult(CheckId id) {
+        return loader.loadPolygon(referenceId).getCheckResult(id);
+    }
+
+    @Override
+    public CheckResult getCheckResult(Check c) {
+        return loader.loadPolygon(referenceId).getCheckResult(c);
+    }
+
+    @Override
+    public Map<CheckId, CheckResult> getAllCheckResults() {
+        return loader.loadPolygon(referenceId).getAllCheckResults();
+    }
+
+    @Override
+    public boolean hasDependencyNotMetError(CheckId id) {
+        return loader.loadPolygon(referenceId).hasDependencyNotMetError(id);
+    }
+
+    @Override
+    public boolean hasAnyErrorWithoutDependencies() {
+        return loader.loadPolygon(referenceId).hasAnyErrorWithoutDependencies();
+    }
+
+    @Override
+    public boolean hasCheckResults() {
+        return loader.loadPolygon(referenceId).hasCheckResults();
+    }
+
+    @Override
+    public void addCheckResult(CheckResult cr) {
+        loader.loadPolygon(referenceId).addCheckResult(cr);
+    }
+
+    @Override
+    public void clearCheckResults() {
+        loader.loadPolygon(referenceId).clearCheckResults();
+    }
+
+    @Override
+    public boolean hasAnyError() {
+        return loader.loadPolygon(referenceId).hasAnyError();
+    }
+
+    @Override
+    public void collectContainedErrors(List<CheckError> errors) {
+        loader.loadPolygon(referenceId).collectContainedErrors(errors);
+    }
+
+    @Override
+    public void collectErrors(List<CheckError> errors) {
+        loader.loadPolygon(referenceId).collectErrors(errors);
+    }
+
+    @Override
+    public Class<? extends Checkable> getCheckClass() {
+        return loader.loadPolygon(referenceId).getCheckClass();
+    }
+
+    @Override
+    public boolean hasExistingGmlId() {
+        return loader.loadPolygon(referenceId).hasExistingGmlId();
+    }
+}