.gitlab-ci.yml

@@ -14,22 +14,28 @@ variables:
   MAVEN_OPTS: "-Djava.awt.headless=true -Dmaven.repo.local=.m2/repository"
   MAVEN_CLI_OPTS: "--batch-mode --errors --fail-at-end --show-version -Dgitlab-ci=true"
 
-build-job:
-  stage: build
-  script:
-    - "mvn clean compile -f tdt4140-gr1800/pom.xml $MAVEN_CLI_OPTS"
+#build-job:
+#  stage: build
+#  script:
+#    - "mvn clean compile -f tdt4140-gr18nn/pom.xml $MAVEN_CLI_OPTS"
+#    - "mvn clean compile -f tdt4140-gr1800/pom.xml $MAVEN_CLI_OPTS"
 
-unittest-job:
-  stage: test
-  dependencies:
-    - build-job
-  script:
-    - "mvn package -f tdt4140-gr1800/pom.xml $MAVEN_CLI_OPTS"
-    - "cat tdt4140-gr1800/app.core/target/site/jacoco/index.html"
+#unittest-job:
+#  stage: test
+#  dependencies:
+#    - build-job
+#  script:
+#    - "mvn test -f tdt4140-gr18nn/pom.xml $MAVEN_CLI_OPTS"
+#    - "mvn test -f tdt4140-gr1800/pom.xml $MAVEN_CLI_OPTS"
+#    - "cat tdt4140-gr1800/app.core/target/site/jacoco/index.html"
 
 integrationtest-job:
   stage: test
-  dependencies:
-    - build-job
+  only:
+    - web
+#  dependencies:
+#    - build-job
   script:
+    - "mvn verify -f tdt4140-gr18nn/pom.xml $MAVEN_CLI_OPTS"
     - "mvn verify -f tdt4140-gr1800/pom.xml $MAVEN_CLI_OPTS"
+    - "cat tdt4140-gr1800/app.core/target/site/jacoco/index.html"

README.md

+# Example repository for the TDT4140 course, Spring 2018
+
+This repository contains templates and examples for the TDT4140 course, for Spring 2018. Currently, it contains two project, both using maven as build system and configured for using Eclipse:
+* [tdt4140-gr18nn](tdt4140-gr18nn/README.md): Template for JavaFX project with two sub-modules, one for the model and one for the UI. To use the template, copy the whole structure and systematically rename files and edit file contents to match your group number.
+* [tdt4140-gr1800](tdt4140-gr1800/README.md): Example project based on the template, and extended to include a web server module.

tdt4140-gr1800/README.md

+# Example project for the TDT4140 course, Spring 2018
+
+This project is an example for Spring 2018, based on the [template project](../tdt4140-gr18nn/README.md). It is meant to illustrate the expected architecture, as well as demonstrate relevant implementation techniques, including project and build configuration and coding and library usage.
+
+This project is about managing sets of geo-locations, like tracks from hiking og training, similar to what you get from apps like Strava. The project includes two systems:
+* a JavaFX app for visualising, analysing and editing sets of geo-locations
+* web server with a REST API for managing sets of geo-locations, primarily for collecting the geo-locations from apps, but also as persistence layer for the JavaFX app
+
+## Getting startet
+
+### Prerequisites
+
+We develop using **Eclipse**, but other IDEs should also work. You also need **maven**, at least a standalone install, but you should also install maven support in Eclipse, by means of the m2e plugins, which are available in Eclipse's main update site.
+
+We use Java 8 and JavaFX, so both these should be installed. Both JDK 8 and JDK 9 should work.
+
+### Installing 
+
+The project uses maven as build system and is accordingly organised as a hierarchical project with a top-level module with several sub-modules. Most IDEs support importing it by point to the top-level module folder, so you should only need to clone the repository and import.
+
+Eclipse will allow you to import using the **Import... > Existing Projects into Workspace** wizard. Make sure to import all sub-module projects (check the box for "nested projects" in the wizard). You should also view it in the **Project Explorer** with **Project Presentation** set to **Hierarchical**.
+
+After importing, you should see the following sub-module projects (contained in the root/aggregator project):
+* [fx-map-control](https://github.com/ClemensFischer/FX-Map-Control) (in FxMapControl folder): Copy of project from github, since it is not (yet?) release on maven central.
+* [tdt4140.gr1800.app.core](app.core/README.md) (in app.core folder): Common domain classes and persistence support.
+* [tdt4140.gr1800.app.ui](app.ui/README.md)  (in app.ui folder): JavaFX app.
+* [tdt4140.gr1800.web.server](web.server/README.md) (in web.server folder): Web server providing a REST API to domain data.
+
+There is no web client project, yet, since that is outside the scope of the course. We may add this later for completeness, and to illustrate the REST API.
+
+## Running the tests
+
+The sub-modules include both ordinary tests and integration tests, use **mvn test** and **mvn integration-test** for running these. The latter is needed for fully testing the web-server project. Note that both kinds of test will be run with **mvn install**.
+
+## Deployment
+
+We have yet to configure deployment of the JavaFX app and the web server. The former must currently be run from the IDE with **Run as > Java Application**, and the latter using **mvn jetty:run**.
+
+## Built with
+* [Jackson](https://github.com/FasterXML/jackson) - [JSON](https://www.json.org) library
+* [JPX](https://github.com/jenetics/jpx) - library for importing [GPX](https://en.wikipedia.org/wiki/GPS_Exchange_Format) files
+* [geojson-jackson](https://github.com/opendatalab-de/geojson-jackson) - library for [GeoJson](http://geojson.org)
+* [HSQLDB](http://www.hsqldb.org) - embedded database with SQL support
+* [FX-Map-Control](https://github.com/ClemensFischer/FX-Map-Control)
+* [TestFX](https://github.com/TestFX/TestFX) - test framework for JavaFX apps
+* [Jetty](https://www.eclipse.org/jetty/) - embedded HTTP server
+
+## Authors
+
+* Hallvard Trætteberg
+
+## License
+
+Not yet decided, probably GPL

tdt4140-gr1800/app.core/README.md

+# app.core module - domain classes for example project
+
+* [Domain model](doc/domain-model.md)
+* [DB-based persistence](doc/db-persistence.md)
+* [JSON-based serialization](doc/json-persistence.md)
+* [Document storage](doc/document-storage.md)

tdt4140-gr1800/app.core/doc/db-persistence.md

+# DB-based persistence of domain data
+
+DB-based persistence is provided by (an implementation of) the **IDbAccess** interface. It includes life-cycle methods corresponding to CRUD operations, so by using these methods, the corresponding DB operations may be performed to keep the DB in sync with the local domain model object structure.
+
+The implementation is split in three:
+* **AbstractDbAccessImpl**: Implements the DB-independent logic, i.e. life-cycle of collections of linked domain objects.
+* **DbAccessImpl**: Inherits from **AbstractDbAccessImpl** and adds DB logic using SQL.
+* **DbAccessHelper**: Helper class for the DB access.
+
+Note that identifiers are not part of the domain model and are handled by the **IdMap** class, which provides a pair of maps from a String identifier to/from domain objects of some type.
+ 
+A class diagram of the main classes related to db-based persistence is shown below.
+
+<img src="db-persistence-classes.png" alt="DB-based persistence" style="width: 800px;"/>

tdt4140-gr1800/app.core/doc/document-storage.md

+# Document-based storage of domain data
+
+By *document-based storage* we mean a storage model where a *document* containing domain data is loaded/saved *as a whole*, from/to some explicitly provided *location*. This storage model is typical for document-centric desktop apps with a **File** menu containing actions like **open**, **save**, **save-as** etc. The interfaces and implementation classes described here are designed to support such **File** menu actions. A class diagram of the main classes related to location-based storage is shown below.
+
+* **IDocumentStorage**: An interface with the methods necessary for supporting the standard **File** menu actions. The interface is parameterized with the type used for representing the location to load from or save to. The class representing the document (domain data container) is implicit in the implementation of this interface. The interface includes methods for getting and setting the location and creating, opening and saving the (current) document.
+* **IDocumentImporter**: An interface with a method for importing domain data from a location. The interface is parameterized with the location type. The main use is supporting an **import** action in a **File** menu. 
+
+* **IDocumentLoader**: An interface with a method for loading and returning a document (domain data container) from an **InputStream**. The interface is parameterized with the document type. This allows various ways of loading or importing domain data, with different sources and formats.
+* **IDocumentSaver**: An interface with a method for saving a document (domain data container) to a location. The interface is parameterized with the document and location types. This allows various ways of saving or exporting domain data, to different locations and formats.
+* **IDocumentPersistence**: Combination of **IDocumentLoader**  and **IDocumentSaver**.
+
+* **IDocumentStorageListener**: Listener interface for the location of the (current) document of an IDocumentStorage, e.g. when a **save-as** action is performed. 
+* **IDocumentListener**: Listener interface for the contents of the (current) document of an IDocumentStorage, e.g. when a document is created, opened or imported.
+
+* **AbstractDocumentStorageImpl**: Incomplete implementation of **IDocumentStorage**, to simplify implementing ones for specific document and location types. The main missing methods are for getting and setting the current document, creating an empty one and creating an **InputStream** from a location.
+
+<img src="location-based-storage.png" alt="Location-based persistence" style="width: 800px;"/>

tdt4140-gr1800/app.core/doc/domain-model.md

+# Domain model for app and REST API
+
+The project is about managing sets of geo-locations, so the domain model includes classes for representing geo-locations, sets of these and owners of such sets. A class diagram of the core model is shown below.
+
+Main types related to geo-locations:
+* **LatLong**: Value class representing a geo-location, i.e. latitude, longitude pair. Includes methods for distance calculations.
+* **GeoLocated**: Interface for geo-located data, i.e. classes that can return a corresponding **LatLong** object.
+* **GeoLocation**: Main implementation of **GeoLocated**. Combines a **LatLong** and *elevation* with generic values like name, description, time (implements **Timed**) and tags (implements **Tagged**).
+* **GeoLocations** (unfortunate name): Container for **GeoLocated** objects. Includes a flag indicating of the geo-locations represents a *path* or not. Implements **Timed** and **Tagged**.  
+* **GeoLocationsOwner**: Container for **GeoLocations** objects. Meant as an abstract class, but is not since it is useful on its own. 
+* **Person**: Main subclass of **GeoLocationsOwner**. Includes *name* and *email* values.
+
+Generally useful types
+* **Timed**: Interface for time-related data, including *date*, *time* of day and time *zone*. The idea is that elements left out are filled in with (default) values from the container.
+* **TimedImpl**: Main implementation of **Timed**.
+* **Tagged**: Interface for tags, i.e. sets of string labels. Includes methods for checking, getting, setting, adding and removing tags.
+* **Tags**: Main implementation of **Tagged**.
+* **TimedTaggedImpl**: Implementation of both **Timed** and **Tagged**, among others used as superclass for **GeoLocation** and **GeoLocations**.
+
+<img src="domain-classes.png" alt="Domain classes" style="width: 800px;"/>

tdt4140-gr1800/app.core/doc/json-persistence.md

+# JSON-based persistence of domain data
+
+JSON support is provided by means of the [Jackson library](https://github.com/FasterXML/jackson), and uses its technique for serializing/deserializing domain objects.

tdt4140-gr1800/app.core/pom.xml

@@ -9,21 +9,49 @@
 		<version>0.0.1-SNAPSHOT</version>
 	</parent>
 
+	<properties>
+		<jackson-version>2.9.3</jackson-version>
+	</properties>
+
 	<dependencies>
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-core</artifactId>
-			<version>2.9.3</version>
+			<version>${jackson-version}</version>
 		</dependency>
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-databind</artifactId>
-			<version>2.9.3</version>
+			<version>${jackson-version}</version>
 		</dependency>
 		<dependency>
 			<groupId>com.fasterxml.jackson.core</groupId>
 			<artifactId>jackson-annotations</artifactId>
-			<version>2.9.3</version>
+			<version>${jackson-version}</version>
+		</dependency>
+		<dependency>
+			<groupId>com.fasterxml.jackson.dataformat</groupId>
+			<artifactId>jackson-dataformat-xml</artifactId>
+			<version>${jackson-version}</version>
+		</dependency>
+
+		<!-- https://mvnrepository.com/artifact/io.jenetics/jpx -->
+		<dependency>
+			<groupId>io.jenetics</groupId>
+			<artifactId>jpx</artifactId>
+			<version>1.2.3</version>
+		</dependency>
+
+		<dependency>
+			<groupId>de.grundid.opendatalab</groupId>
+			<artifactId>geojson-jackson</artifactId>
+			<version>1.8</version>
+		</dependency>
+
+		<dependency>
+			<groupId>org.hsqldb</groupId>
+			<artifactId>hsqldb</artifactId>
+			<version>2.4.0</version>
 		</dependency>
 
 		<dependency>
@@ -56,6 +84,29 @@
 					</execution>
 				</executions>
 			</plugin>
+			<!-- 
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-checkstyle-plugin</artifactId>
+				<version>3.0.0</version>
+				<executions>
+					<execution>
+						<id>verify</id>
+						<phase>verify</phase>
+						<configuration>
+							<configLocation>../checkstyle.xml</configLocation>
+							<failsOnError>false</failsOnError>
+							<encoding>UTF-8</encoding>
+							<consoleOutput>true</consoleOutput>
+							<linkXRef>false</linkXRef>
+						</configuration>
+						<goals>
+							<goal>check</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			 -->
 		</plugins>
 	</build>
 

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/App.java

@@ -4,21 +4,26 @@ import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
-import java.net.URI;
+import java.io.InputStream;
+import java.io.OutputStream;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.stream.Collectors;
 
-import tdt4140.gr1800.app.json.GeoLocationsJsonPersistence;
+import tdt4140.gr1800.app.doc.AbstractDocumentStorageImpl;
+import tdt4140.gr1800.app.doc.IDocumentImporter;
+import tdt4140.gr1800.app.doc.IDocumentLoader;
+import tdt4140.gr1800.app.doc.IDocumentPersistence;
+import tdt4140.gr1800.app.doc.IDocumentStorage;
+import tdt4140.gr1800.app.gpx.GpxDocumentConverter;
+import tdt4140.gr1800.app.json.GeoLocationsPersistence;
 
 public class App {
 
-	private GeoLocationsPersistence geoLocationsLoader = new GeoLocationsJsonPersistence();
+	private GeoLocationsStreamPersistence geoLocationsPersistence = new GeoLocationsPersistence();
 	
-	public void loadGeoLocations(URI uri) throws Exception {
-		geoLocations = geoLocationsLoader.loadLocations(uri.toURL().openStream());
-	}
-
-	private Collection<GeoLocations> geoLocations;
+	private Collection<GeoLocations> geoLocations = null;
 
 	public Iterable<String> getGeoLocationNames() {
 		Collection<String> names = new ArrayList<String>(geoLocations != null ? geoLocations.size() : 0);
@@ -52,9 +57,41 @@ public class App {
 		return null;
 	}
 
+	public Collection<GeoLocations> getGeoLocations(String... names) {
+		Collection<GeoLocations> result = new ArrayList<GeoLocations>();
+		if (geoLocations != null) {
+			if (names != null) {
+				for (String name : names) {
+					GeoLocations gl = getGeoLocations(name);
+					if (gl != null) {
+						result.add(gl);
+					}
+				}
+			} else {
+				result.addAll(geoLocations);
+			}
+		}
+		return result;
+	}
+
 	// 
 
-	private DocumentStorageImpl<Collection<GeoLocations>, File> documentStorage = new DocumentStorageImpl<Collection<GeoLocations>, File>() {
+	private IDocumentPersistence<Collection<GeoLocations>, File> documentPersistence = new IDocumentPersistence<Collection<GeoLocations>, File>() {
+		
+		@Override
+		public Collection<GeoLocations> loadDocument(InputStream inputStream) throws Exception {
+			return geoLocationsPersistence.loadLocations(inputStream);
+		}
+
+		@Override
+		public void saveDocument(Collection<GeoLocations> document, File documentLocation) throws Exception {
+			try (OutputStream output = new FileOutputStream(documentLocation)) {
+				geoLocationsPersistence.saveLocations(document, output);
+			}
+		}
+	};
+
+	private AbstractDocumentStorageImpl<Collection<GeoLocations>, File> documentStorage = new AbstractDocumentStorageImpl<Collection<GeoLocations>, File>() {
 
 		@Override
 		protected Collection<GeoLocations> getDocument() {
@@ -63,7 +100,9 @@ public class App {
 
 		@Override
 		protected void setDocument(Collection<GeoLocations> document) {
-			geoLocations = document;
+			Collection<GeoLocations> oldDocument = getDocument();
+			App.this.geoLocations = document;
+			fireDocumentChanged(oldDocument);
 		}
 
 		@Override
@@ -71,26 +110,47 @@ public class App {
 			return new ArrayList<GeoLocations>();
 		}
 
-		@Override
-		protected Collection<GeoLocations> loadDocument(File file) throws IOException {
-			try {
-				return geoLocationsLoader.loadLocations(new FileInputStream(file));
-			} catch (Exception e) {
-				throw new IOException(e);
+		protected InputStream toInputStream(File storage) throws IOException {
+			return new FileInputStream(storage);
+		}
+		
+		public Collection<GeoLocations> loadDocument(InputStream inputStream) throws Exception {
+			return documentPersistence.loadDocument(inputStream);
 		}
+		
+		public void saveDocument(Collection<GeoLocations> document, File documentLocation) throws Exception {
+			documentPersistence.saveDocument(document, documentLocation);
 		}
 		
+		public Collection<IDocumentImporter> getDocumentImporters() {
+			return documentLoaders.stream().map(loader -> new IDocumentImporter() {
 				@Override
-		protected void storeDocument(Collection<GeoLocations> document, File file) throws IOException {
+				public void importDocument(InputStream inputStream) throws IOException {
 					try {
-				geoLocationsLoader.saveLocations(document, new FileOutputStream(file));
+						setDocumentAndLocation(loader.loadDocument(inputStream), null);
 					} catch (Exception e) {
 						throw new IOException(e);
 					} 
 				}
+			}).collect(Collectors.toList());
+		}
 	};
 
 	public IDocumentStorage<File> getDocumentStorage() {
 		return documentStorage;
 	}
+
+	private Collection<IDocumentLoader<Collection<GeoLocations>>> documentLoaders = Arrays.asList(
+		new IDocumentLoader<Collection<GeoLocations>>() {
+			private GpxDocumentConverter gpxConverter = new GpxDocumentConverter();
+			@Override
+			public Collection<GeoLocations> loadDocument(InputStream inputStream) throws Exception {
+				return gpxConverter.loadDocument(inputStream);
+			}
+		}
+	);
+	
+	public Iterable<IDocumentLoader<Collection<GeoLocations>>> getDocumentLoaders() {
+		return documentLoaders;
+	}
 }

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/DocumentStorageImpl.java

-package tdt4140.gr1800.app.core;
-
-import java.io.IOException;
-
-public abstract class DocumentStorageImpl<D, L> implements IDocumentStorage<L> {
-
-	private L documentLocation;
-
-	@Override
-	public L getDocumentLocation() {
-		return documentLocation;
-	}
-
-	@Override
-	public void setDocumentLocation(L documentLocation) {
-		this.documentLocation = documentLocation;
-	}
-
-	protected abstract D getDocument();
-	protected abstract void setDocument(D document);
-
-	protected abstract D createDocument();
-	protected abstract D loadDocument(L storage) throws IOException;
-	protected abstract void storeDocument(D document, L storage) throws IOException;
-	
-	@Override
-	public void newDocument() {
-		setDocument(createDocument());
-	}
-
-	@Override
-	public void openDocument(L storage) throws IOException {
-		setDocument(loadDocument(storage));
-	}
-
-	@Override
-	public void saveDocument() throws IOException {
-		storeDocument(getDocument(), getDocumentLocation());
-	}
-
-	public void saveDocumentAs(L documentLocation) throws IOException {
-		setDocumentLocation(documentLocation);
-		saveDocument();
-	}
-	
-	public void saveCopyAs(L documentLocation) throws IOException {
-		storeDocument(getDocument(), documentLocation);
-	}
-}

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/GeoLocated.java

+package tdt4140.gr1800.app.core;
+
+/**
+ * Interface for geo-located data, i.e. classes that can return a corresponding LatLong object.
+ * @author hal
+ *
+ */
+public interface GeoLocated {
+
+	/**
+	 * @return the corresponding LatLong object
+	 */
+	public LatLong getLatLong();
+
+	/**
+	 * @return the corresponding latitude
+	 */
+	default double getLatitude() {
+		return getLatLong().latitude;
+	}
+
+	/**
+	 * @return the corresponding longitude
+	 */
+	default double getLongitude() {
+		return getLatLong().longitude;
+	}
+
+	/**
+	 * Checks that the latitudes and longitudes are the same
+	 * @param geoLoc
+	 * @return true if the latitudes and longitudes are the same, false otherwise
+	 */
+	default boolean equalsLatLong(final GeoLocated geoLoc) {
+		return getLatitude() == geoLoc.getLatitude() && getLongitude() == geoLoc.getLongitude();
+	}
+
+	/**
+	 * @param geoLoc
+	 * @return the distance between the LatLong of this GeoLocated and the one provided
+	 */
+	default double distance(final GeoLocated geoLoc) {
+		return getLatLong().distance(geoLoc.getLatLong());
+	}
+}

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/GeoLocation.java

+package tdt4140.gr1800.app.core;
+
+/**
+ * Main implementation of GeoLocated. Combines a LatLong and elevation with generic values
+ * like name, description, time (implements Timed) and tags (implements Tagged).
+ * @author hal
+ *
+ */
+public class GeoLocation extends TimedTaggedImpl implements GeoLocated, Timed, Tagged {
+
+	private LatLong latLong;
+
+	@Override
+	public LatLong getLatLong() {
+		return latLong;
+	}
+
+	public void setLatLong(final LatLong latLong) {
+		this.latLong = latLong;
+	}
+
+	private int elevation;
+
+	public int getElevation() {
+		return elevation;
+	}
+
+	public void setElevation(final int elevation) {
+		this.elevation = elevation;
+	}
+
+	private String name, description;
+
+	public String getName() {
+		return name;
+	}
+
+	public void setName(final String name) {
+		this.name = name;
+	}
+
+	public String getDescription() {
+		return description;
+	}
+
+	public void setDescription(final String description) {
+		this.description = description;
+	}
+}

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/GeoLocations.java

@@ -7,7 +7,17 @@ import java.util.Iterator;
 import java.util.Optional;
 import java.util.stream.Collectors;
 
-public class GeoLocations implements Iterable<LatLong> {
+public class GeoLocations extends TimedTaggedImpl implements Iterable<GeoLocated>, Tagged, Timed {
+
+	private final GeoLocationsOwner owner;
+	
+	public GeoLocations(GeoLocationsOwner owner) {
+		this.owner = owner;
+	}
+
+	public GeoLocationsOwner getOwner() {
+		return owner;
+	}
 	
 	private String name;
 	
@@ -19,12 +29,23 @@ public class GeoLocations implements Iterable<LatLong> {
 		this.name = name;
 	}
 
-	private Collection<LatLong> locations = new ArrayList<LatLong>();
+	private String description;
+
+	public String getDescription() {
+		return description;
+	}
+	
+	public void setDescription(String description) {
+		this.description = description;
+	}
+
+	private Collection<GeoLocated> locations = new ArrayList<GeoLocated>();
 	private boolean path = false;
 	
-	public GeoLocations(LatLong...latLongs) {
-		for (int i = 0; i < latLongs.length; i++) {
-			addLocation(latLongs[i]);
+	public GeoLocations(GeoLocated...geoLocs) {
+		this((GeoLocationsOwner) null);
+		for (int i = 0; i < geoLocs.length; i++) {
+			addLocation(geoLocs[i]);
 		}
 	}
 
@@ -41,34 +62,34 @@ public class GeoLocations implements Iterable<LatLong> {
 		this.path = path;
 	}
 	
-	public Comparator<? super LatLong> closestComparator(LatLong latLong) {
-		return (latLong1, latLong2) -> (int) Math.signum(latLong.distance(latLong1) - latLong.distance(latLong2));
+	public Comparator<? super GeoLocated> closestComparator(GeoLocated latLong) {
+		return (geoLoc1, geoLoc2) -> (int) Math.signum(latLong.distance(geoLoc1) - latLong.distance(geoLoc2));
 	}
 
-	public Collection<LatLong> findLocationsNearby(LatLong latLong, double distance) {
+	public Collection<GeoLocated> findLocationsNearby(GeoLocated geoLoc, double distance) {
 		return locations.stream()
-				.filter(latLong2 -> distance == 0.0 ? latLong2.equals(latLong) : latLong.distance(latLong2) <= distance)
-				.sorted(closestComparator(latLong))
+				.filter(geoLoc2 -> distance == 0.0 ? geoLoc2.equalsLatLong(geoLoc) : geoLoc.distance(geoLoc2) <= distance)
+				.sorted(closestComparator(geoLoc))
 				.collect(Collectors.toList());
 	}
 
-	public LatLong findNearestLocation(LatLong latLong) {
-		Optional<LatLong> min = locations.stream()
-				.min(closestComparator(latLong));
+	public GeoLocated findNearestLocation(GeoLocated geoLoc) {
+		Optional<GeoLocated> min = locations.stream()
+				.min(closestComparator(geoLoc));
 		return min.isPresent() ? min.get() : null;
 	}
 
 	//
 	
-	public void addLocation(LatLong latLong) {
-		locations.add(latLong);
+	public void addLocation(GeoLocated geoLoc) {
+		locations.add(geoLoc);
 	}
 
-	public void removeLocations(LatLong latLong, double distance) {
-		Iterator<LatLong> it = locations.iterator();
+	public void removeLocations(GeoLocated geoLoc, double distance) {
+		Iterator<GeoLocated> it = locations.iterator();
 		while (it.hasNext()) {
-			LatLong latLong2 = it.next();
-			if (distance == 0.0 ? latLong2.equals(latLong) : latLong.distance(latLong2) <= distance) {
+			GeoLocated geoLoc2 = it.next();
+			if (distance == 0.0 ? geoLoc2.equalsLatLong(geoLoc) : geoLoc.getLatLong().distance(geoLoc2.getLatLong()) <= distance) {
 				it.remove();
 			}
 		}
@@ -79,7 +100,7 @@ public class GeoLocations implements Iterable<LatLong> {
 	}
 	
 	@Override
-	public Iterator<LatLong> iterator() {
+	public Iterator<GeoLocated> iterator() {
 		return locations.iterator();
 	}
 }

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/GeoLocationsOwner.java

+package tdt4140.gr1800.app.core;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Iterator;
+
+public class GeoLocationsOwner {
+
+	private Collection<GeoLocations> geoLocations = null;
+
+	public Iterable<String> getGeoLocationsNames() {
+		Collection<String> names = new ArrayList<String>(geoLocations != null ? geoLocations.size() : 0);
+		if (geoLocations != null) {
+			for (GeoLocations geoLocations : geoLocations) {
+				names.add(geoLocations.getName());
+			}
+		}
+		return names;
+	}
+
+	public boolean hasGeoLocations(String... names) {
+		if (geoLocations != null) {
+			outer: for (String name : names) {
+				for (GeoLocations geoLocations : geoLocations) {
+					if (name.equals(geoLocations.getName())) {
+						continue outer;
+					}
+				}
+				return false;
+			}
+			return true;
+		}
+		return names.length == 0;
+	}
+
+	public GeoLocations getGeoLocations(String name) {
+		if (geoLocations != null) {
+			for (GeoLocations geoLocations : geoLocations) {
+				if (name.equals(geoLocations.getName())) {
+					return geoLocations;
+				}
+			}
+		}
+		return null;
+	}
+
+	public Collection<GeoLocations> getGeoLocations(String... names) {
+		Collection<GeoLocations> result = new ArrayList<GeoLocations>();
+		if (geoLocations != null) {
+			if (names != null) {
+				for (GeoLocations geoLocations : geoLocations) {
+					for (String name : names) {
+						if (name.equals(geoLocations.getName())) {
+							result.add(geoLocations);
+						}
+					}
+				}
+			} else {
+				result.addAll(geoLocations);
+			}
+		}
+		return result;
+	}
+
+	//
+
+	public void removeGeolocations(String... names) {
+		if (geoLocations != null) {
+			Iterator<GeoLocations> it = geoLocations.iterator();
+			while (it.hasNext()) {
+				GeoLocations next = it.next();
+				if (names != null) {
+					for (String name : names) {
+						if (name.equals(next.getName())) {
+							it.remove();
+							break;
+						}
+					}
+				} else {
+					it.remove();				
+				}
+			}
+		}
+	}
+
+	public void addGeolocations(GeoLocations geoLocations) {
+		if (this.geoLocations == null) {
+			this.geoLocations = new ArrayList<>();
+		}
+		if (! this.geoLocations.contains(geoLocations)) {
+			this.geoLocations.add(geoLocations);
+		}
+	}
+
+	public void removeGeolocations(GeoLocations geoLocations) {
+		if (this.geoLocations != null) {
+			this.geoLocations.remove(geoLocations);
+		}
+	}
+}

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/GeoLocationsPersistence.java → tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/GeoLocationsStreamPersistence.java

@@ -4,7 +4,7 @@ import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.Collection;
 
-public interface GeoLocationsPersistence {
+public interface GeoLocationsStreamPersistence {
 	public Collection<GeoLocations> loadLocations(InputStream inputStream) throws Exception;
 	public void saveLocations(Collection<GeoLocations> geoLocations, OutputStream outputStream) throws Exception;
 }

tdt4140-gr1800/app.core/src/main/java/tdt4140/gr1800/app/core/IDocumentStorage.java

-package tdt4140.gr1800.app.core;
-
-import java.io.IOException;
-
-public interface IDocumentStorage<L> {
-	public L getDocumentLocation();
-	public void setDocumentLocation(L documentLocation);
-
-	public void newDocument();
-	public void openDocument(L documentLocation) throws IOException;
-	public void saveDocument() throws IOException;
-}