Merge branch '1124_Mark_Sequence_From_RaceXML' into 'develop'

Loading mark sequence from RaceXML

# Loading mark sequence from RaceXML

## Change Log
1. Added MarkOrder class
* Mark order is read from the generated RaceXML and stored
* Added .getNextMark() to get the next mark in the race
* Added .equals() and .hashCode() for Marks
* NEW: Added RacePosition class to hold players position in the race
* NEW: Fixed issue where the duplicates weren't stored in the mark order

## Testing
* Unit tests in models/MarkOrderTest.java

## Acceptance Criteria
* Use the mark sequence in the raceXML
    * Met by change log item (1)

* Store relevant mark details with each participating boat (Last mark, next mark)
    * Method in MarkOrder to get next mark, however the last mark and next mark will need to be stored by whoever implements the second task.

See merge request !52

src/main/java/seng302/model/mark/CompoundMark.java

@@ -86,4 +86,46 @@ public class CompoundMark {
     public List<Mark> getMarks () {
         return marks;
     }
+
+
+//	@Override
+//	public boolean equals(Object other) {
+//		if (other == null) {
+//			return false;
+//		}
+//
+//		if (!(other instanceof Mark)){
+//			return false;
+//		}
+//
+//		Mark otherMark = (Mark) other;
+//
+//		if (otherMark.getLat() != getLat() || otherMark.getLongitude() != getLongitude()) {
+//			return false;
+//		}
+//
+//		if (otherMark.getCompoundMarkID() != getCompoundMarkID()){
+//			return false;
+//		}
+//
+//		if (otherMark.getId() != getId()){
+//			return false;
+//		}
+//
+//		if (!otherMark.getName().equals(name)){
+//			return false;
+//		}
+//
+//		return true;
+//	}
+
+	@Override
+	public int hashCode() {
+    	int hash = 0;
+    	for (Mark mark : marks) {
+    		hash += Double.hashCode(mark.getSourceID()) + Double.hashCode(mark.getLat())
+				+ Double.hashCode(mark.getLng()) + mark.getName().hashCode();
+		}
+		return hash + getName().hashCode() + Integer.hashCode(getId());
+	}
 }

src/main/java/seng302/model/mark/MarkOrder.java

@@ -0,0 +1,135 @@
+package seng302.model.mark;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+import seng302.model.stream.xml.generator.Race;
+import seng302.model.stream.xml.parser.RaceXMLData;
+import seng302.utilities.XMLGenerator;
+import seng302.utilities.XMLParser;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Class to hold the order of the marks in the race.
+ */
+public class MarkOrder {
+    private List<Mark> raceMarkOrder;
+    private Logger logger = LoggerFactory.getLogger(MarkOrder.class);
+
+    public MarkOrder(){
+        loadRaceProperties();
+    }
+
+    /**
+     * @return An ordered list of marks in the race
+     *         OR null if the mark order could not be loaded
+     */
+    public List<Mark> getMarkOrder(){
+        if (raceMarkOrder == null){
+            logger.warn("Race order accessed but not instantiated");
+            return null;
+        }
+
+        return Collections.unmodifiableList(raceMarkOrder);
+    }
+
+    /**
+     * Returns the mark in the race after the previous mark
+     * @param position The current race position
+     * @return the next race position
+     *         OR null if there is no position
+     */
+    public RacePosition getNextPosition(RacePosition position){
+        Mark previousMark = position.getNextMark();
+        Mark nextMark;
+
+        if (position.getPositionIndex() + 1 >= raceMarkOrder.size() - 1){
+            RacePosition nextRacePosition = new RacePosition(raceMarkOrder.size() - 1, null, previousMark);
+            nextRacePosition.setFinishingLeg();
+
+            return nextRacePosition;
+        }
+
+        Integer nextPositionIndex = position.getPositionIndex() + 1;
+        RacePosition nextRacePosition = new RacePosition(nextPositionIndex, raceMarkOrder.get(nextPositionIndex), previousMark);
+
+        return nextRacePosition;
+    }
+
+    /**
+     * Loads the race order from an XML string
+     * @param xml An AC35 RaceXML
+     * @return An ordered list of marks in the race
+     */
+    private List<Mark> loadRaceOrderFromXML(String xml){
+
+        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+        DocumentBuilder db;
+        Document doc;
+
+        try {
+            db = dbf.newDocumentBuilder();
+            doc = db.parse(new InputSource(new StringReader(xml)));
+        } catch (ParserConfigurationException | IOException | SAXException e) {
+            logger.error("Failed to read generated race XML");
+            return null;
+        }
+        
+        RaceXMLData data = XMLParser.parseRace(doc);
+
+        if (data != null){
+            logger.debug("Loaded RaceXML for mark order");
+            List<Corner> corners = data.getMarkSequence();
+            Map<Integer, CompoundMark> marks = data.getCompoundMarks();
+            List<Mark> course = new ArrayList<>();
+
+            for (Corner corner : corners){
+                CompoundMark compoundMark = marks.get(corner.getCompoundMarkID());
+                course.add(compoundMark.getMarks().get(0));
+            }
+
+            return course;
+        }
+
+        return null;
+    }
+
+    /**
+     * @return The first position in the race
+     */
+    public RacePosition getFirstPosition(){
+        if (raceMarkOrder.size() > 0){
+            return new RacePosition(-1, raceMarkOrder.get(0), null);
+        }
+
+        return null;
+    }
+
+    /**
+     * Load the raceXML and mark order
+     */
+    private void loadRaceProperties(){
+        XMLGenerator generator = new XMLGenerator();
+
+        generator.setRace(new Race());
+
+        String raceXML = generator.getRaceAsXml();
+
+        if (raceXML == null){
+            logger.error("Failed to generate raceXML (for race properties)");
+            return;
+        }
+        raceMarkOrder = loadRaceOrderFromXML(raceXML);
+    }
+}

src/main/java/seng302/model/mark/RacePosition.java

@@ -0,0 +1,55 @@
+package seng302.model.mark;
+
+/**
+ * Represents a boats position between two marks
+ */
+public class RacePosition {
+    private Integer positionIndex;
+    private Mark nextMark;
+    private Mark previousMark;
+    private Boolean isFinishingLeg;
+
+    public RacePosition(Integer positionIndex, Mark nextMark, Mark previousMark){
+        this.positionIndex = positionIndex;
+        this.nextMark = nextMark;
+        this.previousMark = previousMark;
+        isFinishingLeg = false;
+    }
+
+    /**
+     * @return The position of the boat (0...number of marks in race - 1)
+     */
+    public Integer getPositionIndex(){
+        return positionIndex;
+    }
+
+    /**
+     * @return The mark the boat is heading to
+     *         will return NULL if this is the finishing legg
+     */
+    public Mark getNextMark(){
+        return nextMark;
+    }
+
+    /**
+     * @return The mark the boat is heading away from,
+     *         Will return NULL if this is the starting leg
+     */
+    public Mark getPreviousMark(){
+        return previousMark;
+    }
+
+    /**
+     * Sets a flag that this is the last leg in the race
+     */
+    public void setFinishingLeg(){
+        isFinishingLeg = true;
+    }
+
+    /**
+     * @return true if this is the last leg in the race
+     */
+    public boolean getIsFinishingLeg() {
+        return isFinishingLeg;
+    }
+}