Merge branch 'gwt' into mak-raceboard

2026-10-04 11:23:50 +00:00 · 2012-01-18 09:41:10 +01:00
commit 3042aad4ec
@@ -8,5 +8,8 @@ Bundle-RequiredExecutionEnvironment: JavaSE-1.6
 Require-Bundle: com.sap.sailing.declination,
 com.sap.sailing.domain,
 com.sap.sailing.domain.common
-Import-Package: junit.framework;version="4.8.1",
+Import-Package: com.sap.sailing.domain.common,
+ com.sap.sailing.domain.common.impl,
+ com.sap.sailing.domain.common.quadtree,
+ junit.framework;version="4.8.1",
 org.junit;version="4.8.1"
@@ -11,8 +11,8 @@ import java.util.regex.Matcher;
 import org.junit.Test;

 import com.sap.sailing.declination.Declination;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.impl.DegreePosition;

 public class DeclinationImportTest extends AbstractDeclinationTest {
    @Test
@@ -13,9 +13,9 @@ import org.junit.Test;
 import com.sap.sailing.declination.Declination;
 import com.sap.sailing.declination.DeclinationService;
 import com.sap.sailing.declination.impl.DeclinationServiceImpl;
-import com.sap.sailing.domain.base.impl.CentralAngleDistance;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.impl.CentralAngleDistance;
+import com.sap.sailing.domain.common.impl.DegreePosition;

 public class DeclinationServiceTest extends AbstractDeclinationTest {
    private DeclinationService service;
@@ -30,13 +30,13 @@ import org.junit.Test;
 import com.sap.sailing.declination.Declination;
 import com.sap.sailing.declination.impl.DeclinationRecordImpl;
 import com.sap.sailing.declination.impl.DeclinationStore;
-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
-import com.sap.sailing.util.QuadTree;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.quadtree.QuadTree;

 public class DeclinationStoreTest extends AbstractDeclinationTest {
    private DeclinationStore store;
@@ -8,10 +8,10 @@ import java.text.ParseException;
 import org.junit.Test;

 import com.sap.sailing.declination.Declination;
-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreePosition;

 public class SimpleDeclinationTest extends AbstractDeclinationTest {
    @Test
@@ -10,3 +10,6 @@ Require-Bundle: com.sap.sailing.domain,
 com.sap.sailing.domain.common
 Export-Package: com.sap.sailing.declination,
 com.sap.sailing.declination.impl;x-friends:="com.sap.sailing.declination.test"
+Import-Package: com.sap.sailing.domain.common,
+ com.sap.sailing.domain.common.impl,
+ com.sap.sailing.domain.common.quadtree
@@ -1,9 +1,9 @@
 package com.sap.sailing.declination;

-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.Timed;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;

 /**
 * Tells the magnetic declination for a position and a given point in time together with an anticipated annual change.
@@ -4,11 +4,11 @@ import java.io.IOException;
 import java.text.ParseException;

 import com.sap.sailing.declination.impl.DeclinationServiceImpl;
-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Mile;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.CentralAngleDistance;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Mile;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.CentralAngleDistance;

 public interface DeclinationService {
    /**
@@ -1,10 +1,10 @@
 package com.sap.sailing.declination.impl;

 import com.sap.sailing.declination.Declination;
-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;

 public class DeclinationRecordImpl implements Declination {
    private final Position position;
@@ -9,10 +9,10 @@ import java.util.Map;

 import com.sap.sailing.declination.Declination;
 import com.sap.sailing.declination.DeclinationService;
-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.util.QuadTree;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.quadtree.QuadTree;

 public class DeclinationServiceImpl implements DeclinationService {
    private final Distance defaultMaxDistance;
@@ -15,13 +15,13 @@ import java.util.Calendar;
 import java.util.GregorianCalendar;

 import com.sap.sailing.declination.Declination;
-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
-import com.sap.sailing.util.QuadTree;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.quadtree.QuadTree;

 /**
 * Manages resources in which declinations can be stored for off-line look-up. Time resolution is
@@ -14,9 +14,9 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 import com.sap.sailing.declination.Declination;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;

 /**
 * Imports magnetic declination data for earth from NOAA (http://www.ngdc.noaa.gov)
@@ -5,4 +5,6 @@ Bundle-SymbolicName: com.sap.sailing.domain.common
 Bundle-Version: 1.0.0.qualifier
 Bundle-Vendor: SAP
 Bundle-RequiredExecutionEnvironment: JavaSE-1.6
-Export-Package: com.sap.sailing.domain.common
+Export-Package: com.sap.sailing.domain.common,
+ com.sap.sailing.domain.common.impl,
+ com.sap.sailing.domain.common.quadtree
@@ -1,6 +1,6 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common;

-import com.sap.sailing.domain.base.Bearing;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;

 public abstract class AbstractBearing implements Bearing {
    @Override
@@ -1,8 +1,6 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Mile;
-import com.sap.sailing.domain.base.Speed;
+import com.sap.sailing.domain.common.impl.KilometersPerHourSpeedImpl;

 public abstract class AbstractDistance implements Distance {

@@ -1,10 +1,11 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common;

-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Position;
+import com.sap.sailing.domain.common.impl.CentralAngleDistance;
+import com.sap.sailing.domain.common.impl.RadianBearingImpl;
+import com.sap.sailing.domain.common.impl.RadianPosition;

 public class AbstractPosition implements Position {
+
    public int hashCode() {
        return (int) (4711. * getLngRad() * getLatRad());
    }
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.base;
+package com.sap.sailing.domain.common;

 public interface Bearing {

@@ -1,9 +1,6 @@
-package com.sap.sailing.util;
-
-import java.util.Locale;
+package com.sap.sailing.domain.common;

 public interface CountryCode {
-    Locale getLocale();

    String getTwoLetterISOCode();

@@ -1,8 +1,6 @@
-package com.sap.sailing.util;
+package com.sap.sailing.domain.common;

-import java.util.Locale;
-
-import com.sap.sailing.util.impl.CountryCodeFactoryImpl;
+import com.sap.sailing.domain.common.impl.CountryCodeFactoryImpl;

 public interface CountryCodeFactory {
    CountryCodeFactory INSTANCE = new CountryCodeFactoryImpl();
@@ -13,10 +11,14 @@ public interface CountryCodeFactory {

    CountryCode getFromTwoLetterISOName(String twoLetterISOName);

+    /**
+     * Note that the three-letter ISO names can also be retrieved from a Java Locale, as follows:
+     * <pre>
+     *          getFromThreeLetterISOName(Locale.GERMANY.getISO3Country().toUpperCase())
+     * </pre>
+     */
    CountryCode getFromThreeLetterISOName(String threeLetterISOName);
    
-    CountryCode getFromLocale(Locale locale);
-    
    CountryCode getFromIANAInternet(String ianaInternet);

    CountryCode getFromUNVehicle(String unVehicle);
@@ -0,0 +1,87 @@
+package com.sap.sailing.domain.common;
+
+
+
+/**
+ * A distance which can be converted to various units of measure. Can be negative.
+ * 
+ * @author Axel Uhl (d043530)
+ *
+ */
+public interface Distance extends Comparable<Distance> {
+    static final Distance NULL = new Distance() {
+        @Override
+        public int compareTo(Distance o) {
+            return getMeters() > o.getMeters() ? 1 : getMeters() == o.getMeters() ? 0 : -1;
+        }
+
+        @Override
+        public double getGeographicalMiles() {
+            return 0;
+        }
+
+        @Override
+        public double getSeaMiles() {
+            return 0;
+        }
+
+        @Override
+        public double getNauticalMiles() {
+            return 0;
+        }
+
+        @Override
+        public double getMeters() {
+            return 0;
+        }
+
+        @Override
+        public double getKilometers() {
+            return 0;
+        }
+
+        @Override
+        public double getCentralAngleDeg() {
+            return 0;
+        }
+
+        @Override
+        public double getCentralAngleRad() {
+            return 0;
+        }
+
+        @Override
+        public Distance scale(double factor) {
+            return this;
+        }
+
+        @Override
+        public Speed inTime(long milliseconds) {
+            return Speed.NULL;
+        }
+        
+    };
+    
+    double getGeographicalMiles();
+
+    double getSeaMiles();
+
+    double getNauticalMiles();
+
+    double getMeters();
+
+    double getKilometers();
+
+    double getCentralAngleDeg();
+
+    double getCentralAngleRad();
+
+    Distance scale(double factor);
+    
+    /**
+     * Computes the (undirected) average speed one has traveled at when passing this distance in the number of
+     * milliseconds specified. Sign-sensitive, meaning, e.g., that if this distance is negative and the time is positive
+     * then the resulting speed will be negative.
+     */
+    Speed inTime(long milliseconds);
+}
@@ -0,0 +1,5 @@
+package com.sap.sailing.domain.common;
+
+public enum ManeuverType {
+    HEAD_UP, BEAR_AWAY, TACK, JIBE, PENALTY_CIRCLE, MARK_PASSING, UNKNOWN;
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.base;
+package com.sap.sailing.domain.common;

 public interface Mile {
    static double METERS_PER_SEA_MILE = 1852.3;
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.base;
+package com.sap.sailing.domain.common;

 public interface Named {
    String getName();
@@ -0,0 +1,115 @@
+package com.sap.sailing.domain.common;
+
+import java.io.Serializable;
+import java.util.Comparator;
+
+/**
+ * Used to define a populated place in the world.<br />
+ * Used by {@link ReverseGeocoder}.
+ * @author Lennart Hensler (D054527)
+ *
+ */
+public interface Placemark extends Serializable {
+    
+    /**
+     * @return The name of the Placemark
+     */
+    String getName();
+    
+    /**
+     * @return The 2 letters country code of the Placemark
+     */
+    String getCountryCode();
+    
+    /**
+     * @return The {@link Position} of the Placemark
+     */
+    Position getPosition();
+    
+    /**
+     * @return The population of the Placemark
+     */
+    long getPopulation();
+
+    /**
+     * @param position The {@link Position} from which the distance is calculated
+     * @return The {@link Distance} between the given {@link Position} and the Placemark
+     */
+    Distance distanceFrom(Position position);
+    
+    /**
+     * Creates a new {@link Position} out of the given coordinates and calculates the distance between {@link Position} and
+     * the Placemark via {@link Placemark#distanceFrom(Position) distanceFrom(Position)}.
+     * @param latDeg Latitude in degrees
+     * @param lngDeg Longitude in degrees
+     * @return The {@link Distance} between the given coordinates and the Placemark
+     */
+    Distance distanceFrom(double latDeg, double lngDeg);
+    
+    /**
+     * @return The name of the country where the Placemark is located
+     */
+    String getCountryName();
+    
+    
+    
+    
+    
+    
+    /**
+     * Sorts the Placemarks by Population from low to high.
+     * @author Lennart Hensler (D054527)
+     *
+     */
+    public class ByPopulation implements Comparator<Placemark> {
+        @Override
+        public int compare(Placemark p1, Placemark p2) {
+            return p1.getPopulation() > p2.getPopulation() ? 1 : p1.getPopulation() < p2.getPopulation() ? -1 : 0;
+        }
+    }
+    
+    /**
+     * Sorts the Placemarks by distance to a {@link Position} from near to far.<br /><br />
+     * 
+     * If you use this for {@link ReverseGeocoder#getPlacemarkLast(Position, float, Comparator) getPlacemarkBest(Position position,...)} to 
+     * get the nearest Placemark for <code>position</code> you can use {@link ReverseGeocoder#getPlacemarkNearest(Position) getPlacemark} instead.
+     * <code>getPlacemark</code> returns per default the nearest Placemark for a Position.
+     * @author Lennart Hensler (D054527)
+     *
+     */
+    public class ByDistance implements Comparator<Placemark> {
+        
+        private Position position;
+        
+        public ByDistance(Position position) {
+            this.position = position;
+        }
+        
+        @Override
+        public int compare(Placemark p1, Placemark p2) {
+            Distance d1 = p1.distanceFrom(position);
+            Distance d2 = p2.distanceFrom(position);
+            
+            return d1.compareTo(d2);
+        }
+    }
+    
+    public class ByPopulationDistanceRatio implements Comparator<Placemark> {
+        
+        private Position position;
+
+        public ByPopulationDistanceRatio(Position position) {
+            this.position = position;
+        }
+
+        @Override
+        public int compare(Placemark p1, Placemark p2) {
+            double r1 = p1.getPopulation() / p1.distanceFrom(position).getKilometers();
+            double r2 = p2.getPopulation() / p2.distanceFrom(position).getKilometers();
+
+            return r1 > r2 ? 1 : r1 < r2 ? -1 : 0;
+        }
+        
+    }
+    
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.base;
+package com.sap.sailing.domain.common;

 public interface Position {
    double getLatRad();
@@ -0,0 +1,9 @@
+package com.sap.sailing.domain.common;
+
+import java.io.Serializable;
+
+public interface RacePlaceOrder extends Serializable {
+
+    Iterable<Placemark> getPlaces();
+    
+}
@@ -0,0 +1,7 @@
+package com.sap.sailing.domain.common;
+
+public interface SerializablePosition extends java.io.Serializable {
+
+    Position getPosition();
+    
+}
@@ -0,0 +1,58 @@
+package com.sap.sailing.domain.common;
+
+/**
+ * A speed, convertable in various units of measure. Can be negative.
+ * 
+ * @author Axel Uhl (d043530)
+ *
+ */
+public interface Speed extends Comparable<Speed> {
+    final static Speed NULL = new Speed() {
+        @Override
+        public int compareTo(Speed o) {
+            return getMetersPerSecond() > o.getMetersPerSecond() ? 1 : getMetersPerSecond() == o.getMetersPerSecond() ? 0 : -1;
+        }
+
+        @Override
+        public double getKnots() {
+            return 0;
+        }
+
+        @Override
+        public double getMetersPerSecond() {
+            return 0;
+        }
+
+        @Override
+        public double getKilometersPerHour() {
+            return 0;
+        }
+
+        @Override
+        public double getBeaufort() {
+            return 0;
+        }
+
+        @Override
+        public Distance travel(TimePoint from, TimePoint to) {
+            return Distance.NULL;
+        }
+        
+    };
+    
+    double getKnots();
+
+    double getMetersPerSecond();
+
+    double getKilometersPerHour();
+    
+    double getBeaufort();
+
+    /**
+     * Traveling at this speed starting at time <code>from</code> until time </code>to</code>, how far have we traveled?
+     * If <code>to</code> is before </code>from</code>, the speed will be applied in reverse. If this speed has a negative
+     * amount then so will the resulting distance.
+     */
+    Distance travel(TimePoint from, TimePoint to);
+
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.base;
+package com.sap.sailing.domain.common;

 import java.util.Date;

@@ -1,9 +1,9 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Mile;
-import com.sap.sailing.domain.base.Speed;
-import com.sap.sailing.domain.base.TimePoint;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Mile;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.TimePoint;

 public abstract class AbstractSpeedImpl implements Speed {

@@ -1,8 +1,8 @@
-package com.sap.sailing.domain.base.impl;
-
-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Mile;
+package com.sap.sailing.domain.common.impl;

+import com.sap.sailing.domain.common.AbstractDistance;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Mile;

 public class CentralAngleDistance extends AbstractDistance {
    private final double centralAngleRad;
@@ -1,14 +1,13 @@
-package com.sap.sailing.util.impl;
+package com.sap.sailing.domain.common.impl;

 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
-import java.util.Locale;
 import java.util.Map;
 import java.util.Set;

-import com.sap.sailing.util.CountryCode;
-import com.sap.sailing.util.CountryCodeFactory;
+import com.sap.sailing.domain.common.CountryCode;
+import com.sap.sailing.domain.common.CountryCodeFactory;

 public class CountryCodeFactoryImpl implements CountryCodeFactory {
    private final Map<String, CountryCode> byThreeLetterIOCName;
@@ -305,11 +304,6 @@ public class CountryCodeFactoryImpl implements CountryCodeFactory {
        all.add(countryCode);
    }

-    @Override
-    public CountryCode getFromLocale(Locale locale) {
-        return getFromThreeLetterISOName(locale.getISO3Country().toUpperCase());
-    }
-
    @Override
    public CountryCode getFromIANAInternet(String ianaInternet) {
        return byIanaInternet.get(ianaInternet.toLowerCase());
@@ -1,8 +1,6 @@
-package com.sap.sailing.util.impl;
+package com.sap.sailing.domain.common.impl;

-import java.util.Locale;
-
-import com.sap.sailing.util.CountryCode;
+import com.sap.sailing.domain.common.CountryCode;

 public class CountryCodeImpl implements CountryCode {
    private final String name;
@@ -42,16 +40,6 @@ public class CountryCodeImpl implements CountryCode {
        return twoLetterISOCode;
    }

-    @Override
-    public Locale getLocale() {
-        for (Locale l : Locale.getAvailableLocales()) {
-            if (l.getISO3Country().equalsIgnoreCase(getThreeLetterISOCode())) {
-                return l;
-            }
-        }
-        return new Locale(getTwoLetterISOCode(), getTwoLetterISOCode());
-    }
-
    @Override
    public String getThreeLetterISOCode() {
        return threeLetterISOCode;
@@ -1,6 +1,8 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;
+
+import com.sap.sailing.domain.common.AbstractBearing;
+import com.sap.sailing.domain.common.Bearing;

-import com.sap.sailing.domain.base.Bearing;

 public class DegreeBearingImpl extends AbstractBearing implements Bearing {
    private final double bearingDeg;
@@ -1,6 +1,9 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;
+
+import com.sap.sailing.domain.common.AbstractPosition;

 public class DegreePosition extends AbstractPosition {
+    
    private final double lat;
    private final double lng;

@@ -1,7 +1,7 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;

-import com.sap.sailing.domain.base.Mile;
-import com.sap.sailing.domain.base.Speed;
+import com.sap.sailing.domain.common.Mile;
+import com.sap.sailing.domain.common.Speed;

 public class KilometersPerHourSpeedImpl extends AbstractSpeedImpl implements Speed {
    private final double speedInKilometersPerHour;
@@ -1,6 +1,6 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;

-import com.sap.sailing.domain.base.Named;
+import com.sap.sailing.domain.common.Named;

 public class NamedImpl implements Named {
    private final String name;
@@ -1,6 +1,7 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;

-import com.sap.sailing.domain.base.Distance;
+import com.sap.sailing.domain.common.AbstractDistance;
+import com.sap.sailing.domain.common.Distance;

 public class NauticalMileDistance extends AbstractDistance {
    private final double nauticalMiles;
@@ -0,0 +1,125 @@
+package com.sap.sailing.domain.common.impl;
+
+import com.sap.sailing.domain.common.CountryCodeFactory;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Placemark;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.SerializablePosition;
+
+/**
+ * Used to define a populated place in the world.<br />
+ * Used by {@link ReverseGeocoder}.
+ * @author Lennart Hensler (D054527)
+ *
+ */
+public class PlacemarkImpl implements Placemark {
+    private static final long serialVersionUID = -7287453946921815463L;
+    
+    private String name;
+    private String countryCode;
+    private SerializablePosition position;
+    private long population;
+    
+    public PlacemarkImpl() {}
+    
+    /**
+     * Creates a new Placemark with the given parameters as attributes.
+     */
+    public PlacemarkImpl(String name, String countryCode, SerializablePosition position, long population) {
+        this.name = name;
+        this.countryCode = countryCode;
+        this.position = position;
+        this.population = population;
+    }
+    
+    /**
+     * Creates a new Placemark with the given parameters as attributes and a <code>population</code> of <code>0</code>;
+     */
+    public PlacemarkImpl(String name, String countryCode, String countryName, SerializablePosition position, String type) {
+        this(name, countryCode, position, 0);
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getCountryCode() {
+        return countryCode;
+    }
+    
+    public Position getPosition() {
+        return position.getPosition();
+    }
+
+    public long getPopulation() {
+        return population;
+    }
+
+
+    @Override
+    public Distance distanceFrom(Position position) {
+        return this.position.getPosition().getDistance(position);
+    }
+    @Override
+    public Distance distanceFrom(double latDeg, double lngDeg) {
+        Position p = new DegreePosition(latDeg, lngDeg);
+        return distanceFrom(p);
+    }
+
+    @Override
+    public String getCountryName() {
+        return CountryCodeFactory.INSTANCE.getFromTwoLetterISOName(countryCode).getName();
+    }
+    
+    @Override
+    public String toString() {
+        StringBuilder b = new StringBuilder(Placemark.class.getSimpleName() + "[");
+        b.append(name + ", ");
+        b.append(countryCode + ", ");
+        b.append(position.toString() + ", ");
+        b.append(population + "]");
+        
+        return b.toString();
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((countryCode == null) ? 0 : countryCode.hashCode());
+        result = prime * result + ((name == null) ? 0 : name.hashCode());
+        result = prime * result + (int) (population ^ (population >>> 32));
+        result = prime * result + ((position == null) ? 0 : position.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        PlacemarkImpl other = (PlacemarkImpl) obj;
+        if (countryCode == null) {
+            if (other.countryCode != null)
+                return false;
+        } else if (!countryCode.equals(other.countryCode))
+            return false;
+        if (name == null) {
+            if (other.name != null)
+                return false;
+        } else if (!name.equals(other.name))
+            return false;
+        if (population != other.population)
+            return false;
+        if (position == null) {
+            if (other.position != null)
+                return false;
+        } else if (!position.equals(other.position))
+            return false;
+        return true;
+    }
+
+}
@@ -0,0 +1,62 @@
+package com.sap.sailing.domain.common.impl;
+
+import com.sap.sailing.domain.common.Placemark;
+import com.sap.sailing.domain.common.RacePlaceOrder;
+
+public class RacePlaceOrderImpl implements RacePlaceOrder {
+    private static final long serialVersionUID = 7590835541329816755L;
+    
+    private Iterable<Placemark> places;
+    
+    RacePlaceOrderImpl() {}
+    
+    public RacePlaceOrderImpl(Iterable<Placemark> places) {
+        this.places = places;
+    }
+
+    @Override
+    public Iterable<Placemark> getPlaces() {
+        return places;
+    }
+    
+    @Override
+    public String toString() {
+        StringBuilder b = new StringBuilder();
+        boolean first = true;
+        for (Placemark place : places) {
+            if (first) {
+                b.append(place.getCountryCode() + ", " + place.getName());
+                first = false;
+            } else {
+                b.append(" -> " + place.getCountryCode() + ", " + place.getName());
+            }
+        }
+        return b.toString();
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((places == null) ? 0 : places.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        RacePlaceOrderImpl other = (RacePlaceOrderImpl) obj;
+        if (places == null) {
+            if (other.places != null)
+                return false;
+        } else if (!places.equals(other.places))
+            return false;
+        return true;
+    }
+
+}
@@ -1,6 +1,7 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;

-import com.sap.sailing.domain.base.Bearing;
+import com.sap.sailing.domain.common.AbstractBearing;
+import com.sap.sailing.domain.common.Bearing;

 public class RadianBearingImpl extends AbstractBearing implements Bearing {
    private final double bearingRad;
@@ -1,6 +1,9 @@
-package com.sap.sailing.domain.base.impl;
+package com.sap.sailing.domain.common.impl;
+
+import com.sap.sailing.domain.common.AbstractPosition;

 public class RadianPosition extends AbstractPosition {
+    
    private final double latRad;
    private final double lngRad;
    
@@ -0,0 +1,53 @@
+package com.sap.sailing.domain.common.impl;
+
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.SerializablePosition;
+
+public class SerializablePositionImpl implements SerializablePosition {
+    private static final long serialVersionUID = -5649921262460723024L;
+    
+    private double latDeg;
+    private double lngDeg;
+    
+    public SerializablePositionImpl() {}
+
+    public SerializablePositionImpl(double latDeg, double lngDeg) {
+        super();
+        this.latDeg = latDeg;
+        this.lngDeg = lngDeg;
+    }
+
+    @Override
+    public Position getPosition() {
+        return new DegreePosition(latDeg, lngDeg);
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(latDeg);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(lngDeg);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        SerializablePositionImpl other = (SerializablePositionImpl) obj;
+        if (Double.doubleToLongBits(latDeg) != Double.doubleToLongBits(other.latDeg))
+            return false;
+        if (Double.doubleToLongBits(lngDeg) != Double.doubleToLongBits(other.lngDeg))
+            return false;
+        return true;
+    }
+
+}
@@ -1,4 +1,4 @@
-package com.sap.sailing.domain.common;
+package com.sap.sailing.domain.common.impl;

 import java.io.Serializable;
 import java.util.Collection;
@@ -20,15 +20,16 @@
 // 
 // **********************************************************************

-package com.sap.sailing.util;
+package com.sap.sailing.domain.common.quadtree;

 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Vector;

-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.impl.DegreePosition;
-import com.sap.sailing.util.impl.QuadTreeNode;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.quadtree.impl.Bounds;
+import com.sap.sailing.domain.common.quadtree.impl.QuadTreeNode;

 /**
 * The QuadTree lets you organize objects in a grid, that redefines
@@ -78,6 +79,10 @@ public class QuadTree<T> implements Serializable {
    public T remove(Position point, T obj) {
        return getTop().remove(point, obj);
    }
+    
+    public void replace(Position point, T newObj) {
+        getTop().replace(point, newObj);
+    }

    /** Clear the tree. */
    public void clear() {
@@ -1,6 +1,6 @@
-package com.sap.sailing.util;
+package com.sap.sailing.domain.common.quadtree.impl;

-import com.sap.sailing.domain.base.Position;
+import com.sap.sailing.domain.common.Position;

 public class Bounds {
    private final Position southWest;
@@ -20,7 +20,7 @@
 // 
 // **********************************************************************

-package com.sap.sailing.util.impl;
+package com.sap.sailing.domain.common.quadtree.impl;

 /**
 * A *really* simple class used as a changable double.
@@ -22,11 +22,11 @@
 // 
 // **********************************************************************

-package com.sap.sailing.util.impl;
+package com.sap.sailing.domain.common.quadtree.impl;

 import java.io.Serializable;

-import com.sap.sailing.domain.base.Position;
+import com.sap.sailing.domain.common.Position;

 public class QuadTreeLeaf<T> implements Serializable {

@@ -20,17 +20,16 @@
 // 
 // **********************************************************************

-package com.sap.sailing.util.impl;
+package com.sap.sailing.domain.common.quadtree.impl;

 import java.io.Serializable;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.Vector;

-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.impl.DegreePosition;
-import com.sap.sailing.util.Bounds;
-import com.sap.sailing.util.QuadTree;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.quadtree.QuadTree;

 /**
 * The QuadTreeNode is the part of the QuadTree that either holds
@@ -169,6 +168,26 @@ public class QuadTreeNode<T> implements Serializable {
    public void put(Position point, T obj) {
        put(new QuadTreeLeaf<T>(point, obj));
    }
+    
+    public void replace(Position point, T newObj) {
+        boolean inThis = false;
+        
+        if (children == null) {
+            inThis = true;
+        } else {
+            QuadTreeNode<T> child = getChild(point);
+            if (child == null) {
+                inThis = true;
+            } else {
+                child.replace(point, newObj);
+            }
+        }
+        
+        if (inThis) {
+            items.clear();
+            items.add(new QuadTreeLeaf<T>(point, newObj));
+        }
+    }

    /**
     * Add a QuadTreeLeaf into the tree at a location.
@@ -11,15 +11,15 @@ import com.mongodb.DB;
 import com.mongodb.DBCollection;
 import com.mongodb.DBObject;
 import com.sap.sailing.domain.base.Event;
-import com.sap.sailing.domain.base.Position;
 import com.sap.sailing.domain.base.RaceDefinition;
 import com.sap.sailing.domain.base.SpeedWithBearing;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.RaceInLeaderboard;
 import com.sap.sailing.domain.leaderboard.ScoreCorrection.MaxPointsReason;
@@ -7,13 +7,13 @@ import com.mongodb.BasicDBObject;
 import com.mongodb.DB;
 import com.mongodb.DBCollection;
 import com.mongodb.DBObject;
-import com.sap.sailing.domain.base.Bearing;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Event;
 import com.sap.sailing.domain.base.RaceDefinition;
-import com.sap.sailing.domain.base.Speed;
 import com.sap.sailing.domain.base.SpeedWithBearing;
 import com.sap.sailing.domain.base.Timed;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.Speed;
 import com.sap.sailing.domain.common.WindSource;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.RaceInLeaderboard;
@@ -14,7 +14,7 @@ import com.mongodb.BasicDBObject;
 import com.mongodb.DB;
 import com.mongodb.DBCollection;
 import com.mongodb.DBObject;
-import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.swisstimingadapter.SailMasterMessage;
 import com.sap.sailing.domain.swisstimingadapter.SailMasterTransceiver;
 import com.sap.sailing.domain.swisstimingadapter.SwissTimingFactory;
@@ -14,13 +14,13 @@ import java.util.Arrays;
 import java.util.Date;
 import java.util.List;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Speed;
 import com.sap.sailing.domain.base.SpeedWithBearing;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.base.impl.KnotSpeedImpl;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MeterDistance;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.swisstimingadapter.Competitor;
 import com.sap.sailing.domain.swisstimingadapter.Mark;
 import com.sap.sailing.domain.swisstimingadapter.Race;
@@ -28,7 +28,7 @@ import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Event;
 import com.sap.sailing.domain.base.RaceDefinition;
 import com.sap.sailing.domain.base.Waypoint;
-import com.sap.sailing.domain.common.Util;
+import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.swisstimingadapter.MessageType;
 import com.sap.sailing.domain.swisstimingadapter.SailMasterConnector;
 import com.sap.sailing.domain.swisstimingadapter.SailMasterTransceiver;
@@ -18,11 +18,11 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.Util;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.swisstimingadapter.Competitor;
 import com.sap.sailing.domain.swisstimingadapter.Course;
 import com.sap.sailing.domain.swisstimingadapter.Fix;
@@ -7,7 +7,7 @@ import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.logging.Logger;

-import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.swisstimingadapter.MessageType;
 import com.sap.sailing.domain.swisstimingadapter.impl.SailMasterMessageImpl;
 import com.sap.sailing.domain.swisstimingadapter.impl.SailMasterTransceiverImpl;
@@ -13,7 +13,7 @@ import com.sap.sailing.domain.base.Event;
 import com.sap.sailing.domain.base.RaceDefinition;
 import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.EventImpl;
-import com.sap.sailing.domain.common.Util;
+import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.swisstimingadapter.Competitor;
 import com.sap.sailing.domain.swisstimingadapter.Course;
 import com.sap.sailing.domain.swisstimingadapter.DomainFactory;
@@ -18,12 +18,12 @@ import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Speed;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.common.Util;
-import com.sap.sailing.domain.common.Util.Pair;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util;
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.swisstimingadapter.Competitor;
 import com.sap.sailing.domain.swisstimingadapter.Course;
 import com.sap.sailing.domain.swisstimingadapter.Fix;
@@ -7,8 +7,8 @@ import com.sap.sailing.domain.base.Course;
 import com.sap.sailing.domain.base.Event;
 import com.sap.sailing.domain.base.Nationality;
 import com.sap.sailing.domain.base.RaceDefinition;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.Waypoint;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.swisstimingadapter.impl.DomainFactoryImpl;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.MarkPassing;
@@ -1,9 +1,9 @@
 package com.sap.sailing.domain.swisstimingadapter;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.Speed;
 import com.sap.sailing.domain.base.SpeedWithBearing;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.Speed;

 /**
 * Data fix transmitted periodically from the SwissTiming Sail Master system, telling boat position and speed
@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.swisstimingadapter;

-import com.sap.sailing.domain.base.TimePoint;
+import com.sap.sailing.domain.common.TimePoint;

 public interface Race extends WithDescription {
    String getRaceID();
@@ -3,9 +3,9 @@ package com.sap.sailing.domain.swisstimingadapter;
 import java.util.Collection;
 import java.util.List;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util.Triple;

 public abstract class SailMasterAdapter implements SailMasterListener {

@@ -6,11 +6,11 @@ import java.text.ParseException;
 import java.util.List;
 import java.util.Map;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Speed;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.common.Util.Pair;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Triple;

 public interface SailMasterConnector {
    SailMasterMessage sendRequestAndGetResponse(MessageType messageType, String... args) throws UnknownHostException, IOException, InterruptedException;
@@ -63,7 +63,7 @@ public interface SailMasterConnector {
    /**
     * Enables receiving RPD (Race Position Data) events to be emitted by the server. If such events are received, they
     * are forwarded to {@link #addSailMasterListener(SailMasterListener) registered} listeners by calling their
-     * {@link SailMasterListener#receivedRacePositionData(String, RaceStatus, TimePoint, TimePoint, Long, Integer, com.sap.sailing.domain.base.Distance, java.util.Collection)}
+     * {@link SailMasterListener#receivedRacePositionData(String, RaceStatus, TimePoint, TimePoint, Long, Integer, com.sap.sailing.domain.common.Distance, java.util.Collection)}
     * method.
     */
    void enableRacePositionData() throws UnknownHostException, IOException, InterruptedException;
@@ -3,9 +3,9 @@ package com.sap.sailing.domain.swisstimingadapter;
 import java.util.Collection;
 import java.util.List;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util.Triple;

 public interface SailMasterListener {
    void receivedRacePositionData(String raceID, RaceStatus status, TimePoint timePoint, TimePoint startTime,
@@ -4,7 +4,7 @@ import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;

-import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Pair;

 public interface SailMasterTransceiver {
    /**
@@ -4,7 +4,7 @@ import java.io.IOException;
 import java.net.UnknownHostException;
 import java.text.ParseException;

-import com.sap.sailing.domain.base.TimePoint;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.swisstimingadapter.impl.SwissTimingFactoryImpl;
 import com.sap.sailing.domain.tracking.TrackedEventRegistry;
 import com.sap.sailing.domain.tracking.WindStore;
@@ -1,8 +1,8 @@
 package com.sap.sailing.domain.swisstimingadapter;

-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.Speed;
-import com.sap.sailing.domain.base.TimePoint;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.udpconnector.UDPMessage;

 public interface SwissTimingMessage extends UDPMessage {
@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.swisstimingadapter;

-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.tracking.RaceTracker;

 public interface SwissTimingRaceTracker extends RaceTracker {
@@ -18,7 +18,6 @@ import com.sap.sailing.domain.base.Nationality;
 import com.sap.sailing.domain.base.Person;
 import com.sap.sailing.domain.base.RaceDefinition;
 import com.sap.sailing.domain.base.Team;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.BoatClassImpl;
 import com.sap.sailing.domain.base.impl.BoatImpl;
@@ -28,7 +27,8 @@ import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.base.impl.PersonImpl;
 import com.sap.sailing.domain.base.impl.RaceDefinitionImpl;
 import com.sap.sailing.domain.base.impl.TeamImpl;
-import com.sap.sailing.domain.common.Util;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.swisstimingadapter.Course;
 import com.sap.sailing.domain.swisstimingadapter.DomainFactory;
 import com.sap.sailing.domain.swisstimingadapter.Fix;
@@ -1,9 +1,9 @@
 package com.sap.sailing.domain.swisstimingadapter.impl;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.Speed;
 import com.sap.sailing.domain.base.SpeedWithBearing;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.Speed;
 import com.sap.sailing.domain.swisstimingadapter.Fix;
 import com.sap.sailing.domain.swisstimingadapter.TrackerType;

@@ -1,6 +1,6 @@
 package com.sap.sailing.domain.swisstimingadapter.impl;

-import com.sap.sailing.domain.base.TimePoint;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.swisstimingadapter.Race;

 public class RaceImpl implements Race {
@@ -24,20 +24,20 @@ import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.logging.Logger;

-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.Speed;
 import com.sap.sailing.domain.base.SpeedWithBearing;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
-import com.sap.sailing.domain.base.impl.KilometersPerHourSpeedImpl;
 import com.sap.sailing.domain.base.impl.KnotSpeedImpl;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MeterDistance;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.Util.Pair;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.impl.KilometersPerHourSpeedImpl;
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.swisstimingadapter.Competitor;
 import com.sap.sailing.domain.swisstimingadapter.Course;
 import com.sap.sailing.domain.swisstimingadapter.Fix;
@@ -6,7 +6,7 @@ import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.charset.Charset;

-import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.swisstimingadapter.SailMasterMessage;
 import com.sap.sailing.domain.swisstimingadapter.SailMasterTransceiver;

@@ -7,8 +7,8 @@ import java.text.ParseException;
 import java.util.HashMap;
 import java.util.Map;

-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.swisstimingadapter.DomainFactory;
 import com.sap.sailing.domain.swisstimingadapter.Race;
 import com.sap.sailing.domain.swisstimingadapter.RaceSpecificMessageLoader;
@@ -1,8 +1,8 @@
 package com.sap.sailing.domain.swisstimingadapter.impl;

-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.Speed;
-import com.sap.sailing.domain.base.TimePoint;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.swisstimingadapter.SwissTimingMessage;

 public class SwissTimingMessageImpl implements SwissTimingMessage {
@@ -2,10 +2,10 @@ package com.sap.sailing.domain.swisstimingadapter.impl;

 import java.net.DatagramPacket;

-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.KilometersPerHourSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.swisstimingadapter.SwissTimingFormatException;
 import com.sap.sailing.domain.swisstimingadapter.SwissTimingMessage;
 import com.sap.sailing.domain.swisstimingadapter.SwissTimingMessageParser;
@@ -13,14 +13,14 @@ import java.util.logging.Logger;

 import com.sap.sailing.domain.base.Buoy;
 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.Distance;
 import com.sap.sailing.domain.base.Event;
 import com.sap.sailing.domain.base.RaceDefinition;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.common.Util;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.swisstimingadapter.Course;
 import com.sap.sailing.domain.swisstimingadapter.DomainFactory;
 import com.sap.sailing.domain.swisstimingadapter.Fix;
@@ -9,8 +9,8 @@ import java.text.SimpleDateFormat;
 import java.util.List;

 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.ManeuverType;
 import com.sap.sailing.domain.tracking.Maneuver;
-import com.sap.sailing.domain.tracking.Maneuver.Type;

 public abstract class AbstractManeuverDetectionTestCase extends OnlineTracTracBasedTest {
    protected SimpleDateFormat dateFormat;
@@ -38,7 +38,7 @@ public abstract class AbstractManeuverDetectionTestCase extends OnlineTracTracBa
     * @param tolerance
     *            The tolerance of time, the maneuver should have happened in milliseconds.
     */
-    protected void assertManeuver(List<Maneuver> maneuverList, Maneuver.Type maneuverType,
+    protected void assertManeuver(List<Maneuver> maneuverList, ManeuverType maneuverType,
            MillisecondsTimePoint maneuverTimePoint, int tolerance) {
        for (Maneuver maneuver : maneuverList) {
            assertNotNull(maneuver.getTimePoint());
@@ -53,18 +53,18 @@ public abstract class AbstractManeuverDetectionTestCase extends OnlineTracTracBa

    /**
     * Checks if there where additional maneuvers of the given types listed in <code>maneuverTypesFound</code> found,
-     * that where not found by {@link ManeuverAnalysisIDMChampionsFinalTest#assertManeuver(List, Type, MillisecondsTimePoint, int)}.
+     * that where not found by {@link ManeuverAnalysisIDMChampionsFinalTest#assertManeuver(List, ManeuverType, MillisecondsTimePoint, int)}.
     * 
     * @param maneuverTypesFound
     *            The maneuver types that should be found.
     * @param maneuversNotDetected
     *            The maneuvers of the types listed in <code>maneuverTypesFound</code> that where not detected by
-     *            {@link ManeuverAnalysisIDMChampionsFinalTest#assertManeuver(List, Type, MillisecondsTimePoint, int)}
+     *            {@link ManeuverAnalysisIDMChampionsFinalTest#assertManeuver(List, ManeuverType, MillisecondsTimePoint, int)}
     */
-    protected void assertAllManeuversOfTypesDetected(List<Maneuver.Type> maneuverTypesFound,
+    protected void assertAllManeuversOfTypesDetected(List<ManeuverType> maneuverTypesFound,
            List<Maneuver> maneuversNotDetected) {
        for (Maneuver maneuver : maneuversNotDetected) {
-            for (Maneuver.Type type : maneuverTypesFound) {
+            for (ManeuverType type : maneuverTypesFound) {
                if (maneuver.getType().equals(type)) {
                    fail("The maneuver "+maneuver+" was detected but not expected");
                }
@@ -4,9 +4,9 @@ import static org.junit.Assert.assertEquals;

 import org.junit.Test;

-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.RadianBearingImpl;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.RadianBearingImpl;

 public class BearingTest {
    @Test
@@ -15,12 +15,12 @@ import org.junit.Before;
 import org.junit.Test;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.base.impl.DouglasPeucker;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MeterDistance;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.tracking.DynamicGPSFixTrack;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.MarkPassing;
@@ -2,6 +2,7 @@ package com.sap.sailing.domain.test;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;

 import java.util.Arrays;
 import java.util.Collections;
@@ -10,10 +11,15 @@ import java.util.Set;

 import org.junit.Test;

-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.RadianBearingImpl;
-import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.base.PositionWithConfidence;
+import com.sap.sailing.domain.base.impl.PositionWithConfidenceImpl;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.impl.RadianBearingImpl;
+import com.sap.sailing.domain.common.impl.Util.Pair;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.confidence.ConfidenceBasedAverager;
 import com.sap.sailing.domain.confidence.ConfidenceBasedAveragerFactory;
 import com.sap.sailing.domain.confidence.HasConfidence;
@@ -133,7 +139,7 @@ public class ConfidenceTest {
    }
    
    @Test
-    public void testAveragingWithThreeoBearings() {
+    public void testAveragingWithThreeBearings() {
        ScalableBearingWithConfidence d1 = new ScalableBearingWithConfidence(new DegreeBearingImpl(350.), 1.);
        ScalableBearingWithConfidence d2 = new ScalableBearingWithConfidence(new DegreeBearingImpl(10.), 1.);
        ScalableBearingWithConfidence d3 = new ScalableBearingWithConfidence(new DegreeBearingImpl(20.), 2.);
@@ -142,5 +148,39 @@ public class ConfidenceTest {
        Bearing average = averager.getAverage(list);
        assertEquals(10, average.getDegrees(), 0.1);
    }
-    
+
+    @Test
+    public void testAveragingTwoPositions() {
+        PositionWithConfidence p1 = new PositionWithConfidenceImpl(new DegreePosition(0, 45), 0.9);
+        PositionWithConfidence p2 = new PositionWithConfidenceImpl(new DegreePosition(0, -45), 0.9);
+        ConfidenceBasedAverager<Triple<Double, Double, Double>, Position> averager = ConfidenceBasedAveragerFactory.INSTANCE.createAverager();
+        List<PositionWithConfidence> list = Arrays.asList(p1, p2);
+        Position average = averager.getAverage(list);
+        assertEquals(0, average.getLatDeg(), 0.1);
+        assertEquals(0, average.getLngDeg(), 0.1);
+    }
+
+    @Test
+    public void testAveragingTwoPositionsToNorthPole() {
+        PositionWithConfidence p1 = new PositionWithConfidenceImpl(new DegreePosition(45, 90), 0.9);
+        PositionWithConfidence p2 = new PositionWithConfidenceImpl(new DegreePosition(45, -90), 0.9);
+        ConfidenceBasedAverager<Triple<Double, Double, Double>, Position> averager = ConfidenceBasedAveragerFactory.INSTANCE.createAverager();
+        List<PositionWithConfidence> list = Arrays.asList(p1, p2);
+        Position average = averager.getAverage(list);
+        assertEquals(90, average.getLatDeg(), 0.1);
+        assertEquals(0, average.getLngDeg(), 0.1);
+    }
+
+    @Test
+    public void testAveragingThreePositions() {
+        PositionWithConfidence p1 = new PositionWithConfidenceImpl(new DegreePosition(49, 8), 0.9);
+        PositionWithConfidence p2 = new PositionWithConfidenceImpl(new DegreePosition(49, 9), 0.9);
+        PositionWithConfidence p3 = new PositionWithConfidenceImpl(new DegreePosition(50, 8.5), 0.9);
+        ConfidenceBasedAverager<Triple<Double, Double, Double>, Position> averager = ConfidenceBasedAveragerFactory.INSTANCE.createAverager();
+        List<PositionWithConfidence> list = Arrays.asList(p1, p2, p3);
+        Position average = averager.getAverage(list);
+        assertTrue(average.getLatDeg() > 49);
+        assertTrue(average.getLatDeg() < 50);
+        assertEquals(8.5, average.getLngDeg(), 0.000000001);
+    }
 }
@@ -18,9 +18,9 @@ import java.util.regex.Pattern;
 import org.junit.Ignore;
 import org.junit.Test;

-import com.sap.sailing.domain.common.Util;
-import com.sap.sailing.util.CountryCode;
-import com.sap.sailing.util.CountryCodeFactory;
+import com.sap.sailing.domain.common.CountryCode;
+import com.sap.sailing.domain.common.CountryCodeFactory;
+import com.sap.sailing.domain.common.impl.Util;

 public class CountryCodeTest {
    private static final int NUMBER_OF_COUNTRY_CODES = 259;
@@ -90,7 +90,7 @@ public class CountryCodeTest {
        cc = ccf.getFromThreeLetterIOCName("GER");
        assertEquals("DE", cc.getTwoLetterISOCode().toUpperCase());
        assertEquals("DEU", cc.getThreeLetterISOCode().toUpperCase());
-        cc = ccf.getFromLocale(Locale.GERMANY);
+        cc = ccf.getFromThreeLetterISOName(Locale.GERMANY.getISO3Country().toUpperCase());
        assertEquals("DE", cc.getTwoLetterISOCode().toUpperCase());
        assertEquals("DEU", cc.getThreeLetterISOCode().toUpperCase());
        cc = ccf.getFromIANAInternet("sd");
@@ -13,7 +13,7 @@ import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.BuoyImpl;
 import com.sap.sailing.domain.base.impl.CourseImpl;
 import com.sap.sailing.domain.base.impl.WaypointImpl;
-import com.sap.sailing.domain.common.Util;
+import com.sap.sailing.domain.common.impl.Util;

 public class CourseTest {
    @Test
@@ -28,8 +28,8 @@ import com.sap.sailing.domain.base.RaceDefinition;
 import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.BuoyImpl;
 import com.sap.sailing.domain.base.impl.WaypointImpl;
-import com.sap.sailing.domain.common.Util;
-import com.sap.sailing.domain.common.Util.Triple;
+import com.sap.sailing.domain.common.impl.Util;
+import com.sap.sailing.domain.common.impl.Util.Triple;
 import com.sap.sailing.domain.tracking.DynamicRaceDefinitionSet;
 import com.sap.sailing.domain.tracking.DynamicTrackedEvent;
 import com.sap.sailing.domain.tracking.TrackedLeg;
@@ -9,12 +9,12 @@ import java.net.URISyntaxException;
 import org.junit.Test;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.WindSource;
-import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.leaderboard.RaceInLeaderboard;
 import com.sap.sailing.domain.leaderboard.impl.LeaderboardImpl;
 import com.sap.sailing.domain.leaderboard.impl.ResultDiscardingRuleImpl;
@@ -15,7 +15,6 @@ import org.junit.Before;
 import org.junit.Test;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.impl.BoatClassImpl;
 import com.sap.sailing.domain.base.impl.BoatImpl;
 import com.sap.sailing.domain.base.impl.CompetitorImpl;
@@ -24,8 +23,9 @@ import com.sap.sailing.domain.base.impl.NationalityImpl;
 import com.sap.sailing.domain.base.impl.PersonImpl;
 import com.sap.sailing.domain.base.impl.TeamImpl;
 import com.sap.sailing.domain.common.NoWindException;
-import com.sap.sailing.domain.common.Util;
-import com.sap.sailing.domain.common.Util.Pair;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.Util;
+import com.sap.sailing.domain.common.impl.Util.Pair;
 import com.sap.sailing.domain.leaderboard.Leaderboard;
 import com.sap.sailing.domain.leaderboard.RaceInLeaderboard;
 import com.sap.sailing.domain.leaderboard.ScoreCorrection.MaxPointsReason;
@@ -15,11 +15,12 @@ import org.junit.Before;
 import org.junit.Test;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.ManeuverType;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.tracking.Maneuver;
 import com.sap.sailing.domain.tracking.impl.WindImpl;
 import com.sap.sailing.domain.tractracadapter.ReceiverType;
@@ -59,11 +60,11 @@ public class ManeuverAnalysis505Test extends AbstractManeuverDetectionTestCase {
                new MillisecondsTimePoint(toDate));
        maneuversInvalid = new ArrayList<Maneuver>(maneuvers);

-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:28:24")), TACK_TOLERANCE);

-        List<Maneuver.Type> maneuverTypesFound = new ArrayList<Maneuver.Type>();
-        maneuverTypesFound.add(Maneuver.Type.TACK);
+        List<ManeuverType> maneuverTypesFound = new ArrayList<ManeuverType>();
+        maneuverTypesFound.add(ManeuverType.TACK);
        assertAllManeuversOfTypesDetected(maneuverTypesFound, maneuversInvalid);
    }
    
@@ -82,64 +83,64 @@ public class ManeuverAnalysis505Test extends AbstractManeuverDetectionTestCase {
                new MillisecondsTimePoint(toDate));
        maneuversInvalid = new ArrayList<Maneuver>(maneuvers);
        
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:28:24")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:38:01")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:40:28")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:40:52")), TACK_TOLERANCE);

-        assertManeuver(maneuvers, Maneuver.Type.JIBE,
+        assertManeuver(maneuvers, ManeuverType.JIBE,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:46:07")), JIBE_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE,
+        assertManeuver(maneuvers, ManeuverType.JIBE,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:49:06")), JIBE_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE,
+        assertManeuver(maneuvers, ManeuverType.JIBE,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:50:41")), JIBE_TOLERANCE);

-        assertManeuver(maneuvers, Maneuver.Type.PENALTY_CIRCLE,
+        assertManeuver(maneuvers, ManeuverType.PENALTY_CIRCLE,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:53:45")), PENALTYCIRCLE_TOLERANCE);

-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:54:01")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-15:58:27")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:03:19")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:04:41")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:05:25")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:05:43")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:06:16")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:07:33")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:11:27")), TACK_TOLERANCE);

-        assertManeuver(maneuvers, Maneuver.Type.JIBE,
+        assertManeuver(maneuvers, ManeuverType.JIBE,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:13:28")), JIBE_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE,
+        assertManeuver(maneuvers, ManeuverType.JIBE,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:18:37")), JIBE_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE,
+        assertManeuver(maneuvers, ManeuverType.JIBE,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:21:28")), JIBE_TOLERANCE);

-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:26:14")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:28:21")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:31:29")), TACK_TOLERANCE);
-        assertManeuver(maneuvers, Maneuver.Type.TACK,
+        assertManeuver(maneuvers, ManeuverType.TACK,
                new MillisecondsTimePoint(dateFormat.parse("06/23/2011-16:38:00")), TACK_TOLERANCE);

-        List<Maneuver.Type> maneuverTypesFound = new ArrayList<Maneuver.Type>();
-        maneuverTypesFound.add(Maneuver.Type.TACK);
-        maneuverTypesFound.add(Maneuver.Type.JIBE);
-        maneuverTypesFound.add(Maneuver.Type.PENALTY_CIRCLE);
+        List<ManeuverType> maneuverTypesFound = new ArrayList<ManeuverType>();
+        maneuverTypesFound.add(ManeuverType.TACK);
+        maneuverTypesFound.add(ManeuverType.JIBE);
+        maneuverTypesFound.add(ManeuverType.PENALTY_CIRCLE);
        assertAllManeuversOfTypesDetected(maneuverTypesFound, maneuversInvalid);
    }
 }
@@ -18,15 +18,16 @@ import org.junit.Test;

 import com.sap.sailing.domain.base.Buoy;
 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.Waypoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.ManeuverType;
 import com.sap.sailing.domain.common.NoWindException;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.Maneuver;
 import com.sap.sailing.domain.tracking.impl.GPSFixImpl;
@@ -94,10 +95,10 @@ public class ManeuverAnalysisIDMChampionsFinalTest extends AbstractManeuverDetec
        List<Maneuver> maneuvers = getTrackedRace().getManeuvers(competitor, new MillisecondsTimePoint(fromDate),
                new MillisecondsTimePoint(toDate));
        maneuversInvalid = new ArrayList<Maneuver>(maneuvers);
-        assertManeuver(maneuvers, Maneuver.Type.PENALTY_CIRCLE,
+        assertManeuver(maneuvers, ManeuverType.PENALTY_CIRCLE,
                new MillisecondsTimePoint(maneuverTime), PENALTYCIRCLE_TOLERANCE);
-        List<Maneuver.Type> maneuverTypesFound = new ArrayList<Maneuver.Type>();
-        maneuverTypesFound.add(Maneuver.Type.PENALTY_CIRCLE);
+        List<ManeuverType> maneuverTypesFound = new ArrayList<ManeuverType>();
+        maneuverTypesFound.add(ManeuverType.PENALTY_CIRCLE);
        assertAllManeuversOfTypesDetected(maneuverTypesFound, maneuversInvalid);
    }
    
@@ -18,19 +18,19 @@ import org.junit.Before;
 import org.junit.Test;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.TimePoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.base.impl.DouglasPeucker;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MeterDistance;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.ManeuverType;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.Tack;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.GPSFixTrack;
 import com.sap.sailing.domain.tracking.Maneuver;
-import com.sap.sailing.domain.tracking.Maneuver.Type;
 import com.sap.sailing.domain.tracking.MarkPassing;
 import com.sap.sailing.domain.tracking.impl.WindImpl;
 import com.sap.sailing.domain.tractracadapter.ReceiverType;
@@ -83,20 +83,20 @@ public class ManeuverDetectionOnKielerWoche505Race2DataTest extends OnlineTracTr
                hassosMarkPassings.last().getTimePoint());
        Calendar c = new GregorianCalendar(TimeZone.getTimeZone("Europe/Berlin"));
        c.set(2011, 6-1, 23, 16, 5, 49);
-        assertManeuver(maneuvers, Maneuver.Type.TACK, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.TACK, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 6-1, 23, 16, 8, 37);
-        assertManeuver(maneuvers, Maneuver.Type.TACK, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.TACK, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 6-1, 23, 16, 11, 03);
-        assertManeuver(maneuvers, Maneuver.Type.TACK, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.TACK, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 6-1, 23, 16, 16, 13);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.JIBE, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 6-1, 23, 16, 20, 1);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.JIBE, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 6-1, 23, 16, 22, 25);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.JIBE, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
    }

-    private void assertManeuver(List<Maneuver> maneuvers, Type type, Tack newTack,
+    private void assertManeuver(List<Maneuver> maneuvers, ManeuverType type, Tack newTack,
            MillisecondsTimePoint timePoint, int toleranceInMilliseconds) {
        for (Maneuver maneuver : maneuvers) {
            if (maneuver.getType() == type && (newTack == null || newTack == maneuver.getNewTack()) &&
@@ -18,18 +18,18 @@ import org.junit.Test;

 import com.sap.sailing.domain.base.Buoy;
 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.Waypoint;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.ManeuverType;
 import com.sap.sailing.domain.common.NoWindException;
+import com.sap.sailing.domain.common.Position;
 import com.sap.sailing.domain.common.Tack;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.tracking.Maneuver;
-import com.sap.sailing.domain.tracking.Maneuver.Type;
 import com.sap.sailing.domain.tracking.MarkPassing;
 import com.sap.sailing.domain.tracking.impl.GPSFixImpl;
 import com.sap.sailing.domain.tracking.impl.WindImpl;
@@ -76,16 +76,16 @@ public class ManeuverDetectionOnMdM2011SemifinalTest extends OnlineTracTracBased
                dennisMarkPassings.last().getTimePoint());
        Calendar c = new GregorianCalendar(TimeZone.getTimeZone("Europe/Berlin"));
        c.set(2011, 10-1, 30, 13, 32, 42);
-        assertManeuver(maneuvers, Maneuver.Type.TACK, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.TACK, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 10-1, 30, 13, 34, 00);
-        assertManeuver(maneuvers, Maneuver.Type.TACK, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.TACK, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 10-1, 30, 13, 35, 46);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.JIBE, Tack.STARBOARD, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
        c.set(2011, 10-1, 30, 13, 36, 49);
-        assertManeuver(maneuvers, Maneuver.Type.JIBE, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
+        assertManeuver(maneuvers, ManeuverType.JIBE, Tack.PORT, new MillisecondsTimePoint(c.getTime()), /* tolerance in milliseconds */ 3000);
    }

-    private void assertManeuver(List<Maneuver> maneuvers, Type type, Tack newTack,
+    private void assertManeuver(List<Maneuver> maneuvers, ManeuverType type, Tack newTack,
            MillisecondsTimePoint timePoint, int toleranceInMilliseconds) {
        for (Maneuver maneuver : maneuvers) {
            if (maneuver.getType() == type && (newTack == null || newTack == maneuver.getNewTack()) &&
@@ -6,8 +6,8 @@ import com.sap.sailing.domain.base.BoatClass;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Course;
 import com.sap.sailing.domain.base.RaceDefinition;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.common.NoWindException;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.test.mock.MockedTrackedRace;

 public class MockedTrackedRaceWithFixedRank extends MockedTrackedRace {
@@ -20,12 +20,12 @@ import org.junit.Before;
 import com.sap.sailing.domain.base.Buoy;
 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Event;
-import com.sap.sailing.domain.base.Position;
 import com.sap.sailing.domain.base.RaceDefinition;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.Waypoint;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.tracking.DynamicRaceDefinitionSet;
 import com.sap.sailing.domain.tracking.DynamicTrackedEvent;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
@@ -10,7 +10,7 @@ import java.util.Collections;
 import org.junit.Test;

 import com.maptrack.client.io.TypeController;
-import com.sap.sailing.domain.base.Position;
+import com.sap.sailing.domain.common.Position;
 import com.sap.sailing.domain.tractracadapter.DomainFactory;
 import com.sap.sailing.domain.tractracadapter.Receiver;
 import com.tractrac.clientmodule.ControlPoint;
@@ -6,16 +6,16 @@ import static org.junit.Assert.assertTrue;

 import org.junit.Test;

-import com.sap.sailing.domain.base.Bearing;
-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Mile;
-import com.sap.sailing.domain.base.Position;
 import com.sap.sailing.domain.base.SpeedWithBearing;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
-import com.sap.sailing.domain.base.impl.NauticalMileDistance;
+import com.sap.sailing.domain.common.Bearing;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Mile;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.impl.NauticalMileDistance;
 import com.sap.sailing.domain.tracking.impl.CompactGPSFixImpl;
 import com.sap.sailing.domain.tracking.impl.CompactGPSFixMovingImpl;

@@ -4,9 +4,9 @@ import static org.junit.Assert.assertNotNull;

 import org.junit.Test;

-import com.sap.sailing.domain.base.Position;
-import com.sap.sailing.domain.base.impl.DegreePosition;
-import com.sap.sailing.util.QuadTree;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.impl.DegreePosition;
+import com.sap.sailing.domain.common.quadtree.QuadTree;

 public class QuadTreeTest {
    private class GLatLngQuadTree extends QuadTree<Position> {
@@ -11,7 +11,7 @@ import org.junit.Test;

 import com.maptrack.client.io.TypeController;
 import com.sap.sailing.domain.base.Course;
-import com.sap.sailing.domain.common.Util;
+import com.sap.sailing.domain.common.impl.Util;
 import com.sap.sailing.domain.tractracadapter.DomainFactory;
 import com.sap.sailing.domain.tractracadapter.Receiver;
 import com.tractrac.clientmodule.Route;
@@ -18,19 +18,19 @@ import java.util.Set;

 import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.Person;
-import com.sap.sailing.domain.base.Position;
 import com.sap.sailing.domain.base.SpeedWithBearing;
 import com.sap.sailing.domain.base.Team;
-import com.sap.sailing.domain.base.TimePoint;
 import com.sap.sailing.domain.base.impl.BoatClassImpl;
 import com.sap.sailing.domain.base.impl.BoatImpl;
 import com.sap.sailing.domain.base.impl.CompetitorImpl;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.base.impl.PersonImpl;
 import com.sap.sailing.domain.base.impl.TeamImpl;
+import com.sap.sailing.domain.common.Position;
+import com.sap.sailing.domain.common.TimePoint;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.tracking.DynamicGPSFixTrack;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.impl.DynamicGPSFixMovingTrackImpl;
@@ -11,8 +11,6 @@ import com.sap.sailing.domain.base.Competitor;
 import com.sap.sailing.domain.base.impl.BoatClassImpl;
 import com.sap.sailing.domain.base.impl.BoatImpl;
 import com.sap.sailing.domain.base.impl.CompetitorImpl;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
 import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.base.impl.NationalityImpl;
@@ -20,6 +18,8 @@ import com.sap.sailing.domain.base.impl.PersonImpl;
 import com.sap.sailing.domain.base.impl.TeamImpl;
 import com.sap.sailing.domain.common.NoWindException;
 import com.sap.sailing.domain.common.Tack;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.tracking.DynamicGPSFixTrack;
 import com.sap.sailing.domain.tracking.GPSFixMoving;
 import com.sap.sailing.domain.tracking.Wind;
@@ -13,8 +13,6 @@ import com.sap.sailing.domain.base.Waypoint;
 import com.sap.sailing.domain.base.impl.BoatClassImpl;
 import com.sap.sailing.domain.base.impl.BuoyImpl;
 import com.sap.sailing.domain.base.impl.CourseImpl;
-import com.sap.sailing.domain.base.impl.DegreeBearingImpl;
-import com.sap.sailing.domain.base.impl.DegreePosition;
 import com.sap.sailing.domain.base.impl.EventImpl;
 import com.sap.sailing.domain.base.impl.GateImpl;
 import com.sap.sailing.domain.base.impl.KnotSpeedWithBearingImpl;
@@ -22,6 +20,8 @@ import com.sap.sailing.domain.base.impl.MillisecondsTimePoint;
 import com.sap.sailing.domain.base.impl.RaceDefinitionImpl;
 import com.sap.sailing.domain.base.impl.WaypointImpl;
 import com.sap.sailing.domain.common.WindSource;
+import com.sap.sailing.domain.common.impl.DegreeBearingImpl;
+import com.sap.sailing.domain.common.impl.DegreePosition;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.TrackedEvent;
 import com.sap.sailing.domain.tracking.impl.DynamicTrackedRaceImpl;
@@ -15,9 +15,9 @@ import org.junit.Before;
 import org.junit.Test;

 import com.sap.sailing.domain.base.Competitor;
-import com.sap.sailing.domain.base.Distance;
-import com.sap.sailing.domain.base.Speed;
-import com.sap.sailing.domain.base.TimePoint;
+import com.sap.sailing.domain.common.Distance;
+import com.sap.sailing.domain.common.Speed;
+import com.sap.sailing.domain.common.TimePoint;
 import com.sap.sailing.domain.tracking.DynamicGPSFixTrack;
 import com.sap.sailing.domain.tracking.DynamicTrackedRace;
 import com.sap.sailing.domain.tracking.GPSFixMoving;