Merge branch 'wake_remake' into Story30b_correcting_boat_movement

# Conflicts:
#	src/main/java/seng302/controllers/CanvasController.java
#	src/main/java/seng302/models/BoatGroup.java
#	src/main/java/seng302/models/parsers/StreamParser.java

src/main/java/seng302/models/parsers/BoatsParser.java

@@ -0,0 +1,77 @@
+package seng302.models.parsers;
+
+import org.w3c.dom.*;
+import org.xml.sax.InputSource;
+import seng302.models.Boat;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import java.io.InputStream;
+import java.io.StringBufferInputStream;
+import java.io.StringReader;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+/**
+ * Created by ryan_ on 30/04/2017.
+ */
+public class BoatsParser extends FileParser {
+    private Document doc;
+
+    public BoatsParser(String xmlString) {
+        this.doc = this.parseFile(xmlString);
+    }
+
+    /**
+     * Create a boat instance from a given node if 'Type' is 'Yacht'
+     *
+     * @param node a boat node
+     * @return an instance of Boat
+     */
+    private Boat parseBoat(Node node) {
+        try {
+            if (node.getNodeType() == Node.ELEMENT_NODE) {
+                Element element = (Element) node;
+                if (element.getAttribute("Type").equals("Yacht")) {
+                    String sourceID = element.getAttribute("SourceID");
+                    String boatName = element.getAttribute("BoatName");
+                    String shortName = element.getAttribute("ShortName");
+                    String stoweName = element.getAttribute("StoweName");
+                    String country = element.getAttribute("Country");
+                    Boat boat = new Boat(Integer.parseInt(sourceID), boatName, shortName, country);
+                    return boat;
+                }
+            } else {
+                throw new NoSuchElementException("Cannot generate a boat by given node");
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    /**
+     * Returns a list of boats from the xml.
+     *
+     * @return a list of boats
+     */
+    public List<Boat> getBoats() {
+        ArrayList<Boat> boats = new ArrayList<>();
+
+        try {
+            NodeList nodes = this.doc.getElementsByTagName("Boat");
+            for (int i = 0; i < nodes.getLength(); i++) {
+                Node node = nodes.item(i);
+                Boat boat = parseBoat(node);
+                if (!(boat == null)) {
+                    boats.add(boat);
+                }
+            }
+            return boats;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+}

src/main/java/seng302/models/parsers/CourseParser.java

@@ -35,7 +35,8 @@ public class CourseParser extends FileParser {
 				String name = element.getElementsByTagName("name").item(0).getTextContent();
 				double lat = Double.valueOf(element.getElementsByTagName("latitude").item(0).getTextContent());
 				double lon = Double.valueOf(element.getElementsByTagName("longitude").item(0).getTextContent());
-				SingleMark singleMark = new SingleMark(name, lat, lon);
+				int id = Integer.valueOf(element.getElementsByTagName("id").item(0).getTextContent());
+				SingleMark singleMark = new SingleMark(name, lat, lon, id);
 				return singleMark;
 			} else {
 				throw new NoSuchElementException("Cannot generate a mark by given node.");

src/main/java/seng302/models/parsers/FileParser.java

@@ -1,12 +1,14 @@
 package seng302.models.parsers;
 
 import org.w3c.dom.Document;
+import org.xml.sax.InputSource;
 
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.StringReader;
 
 /**
  * Created by Haoming Yin (hyi25) on 16/3/2017
@@ -15,6 +17,8 @@ public abstract class FileParser {
 
     private String filePath;
 
+    public FileParser() {}
+
     public FileParser(String path) {
         this.filePath = path;
     }
@@ -32,6 +36,19 @@ public abstract class FileParser {
             e.printStackTrace();
             return null;
         }
+    }
 
+    protected Document parseFile(String xmlString) {
+        try {
+            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+            DocumentBuilder builder = factory.newDocumentBuilder();
+            Document doc = builder.parse(new InputSource(new StringReader(xmlString)));
+            // optional, in order to recover info from broken line.
+            doc.getDocumentElement().normalize();
+            return doc;
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
     }
 }

src/main/java/seng302/models/parsers/StreamPacket.java

@@ -22,7 +22,7 @@ public class StreamPacket {
 //        if (this.type == PacketType.XML_MESSAGE){
 //            //System.out.println("--------");
 //            System.out.println(new String(payload));
-//            StreamParser.parsePacket(this);
+//            //StreamParser.parsePacket(this);
 //        }
     }
 

src/main/java/seng302/models/parsers/StreamParser.java

@@ -32,10 +32,10 @@ public class StreamParser extends Thread{
      private String threadName;
      private Thread t;
      private static boolean raceStarted = false;
-
-
-
-
+     private static boolean raceFinished = false;
+     private static boolean streamStatus = false;
+     private static long timeSinceStart = -1;
+     private static List<Boat> boats = new ArrayList<>();
 
      public StreamParser(String threadName){
          this.threadName = threadName;
@@ -48,6 +48,7 @@ public class StreamParser extends Thread{
     public void run(){
          try {
              System.out.println("START OF STREAM");
+             streamStatus = true;
              while (StreamReceiver.packetBuffer == null || StreamReceiver.packetBuffer.size() < 1) {
                  Thread.sleep(1);
              }
@@ -158,16 +159,21 @@ public class StreamParser extends Thread{
         format.setTimeZone(TimeZone.getTimeZone("UTC"));
         long timeTillStart = ((new Date (expectedStartTime)).getTime() - (new Date (currentTime)).getTime())/1000;
         if (timeTillStart > 0 && timeTillStart % 10 == 0) {
+            timeSinceStart = timeTillStart;
             System.out.println("Time till start: " + timeTillStart + " Seconds");
         } else {
             if (raceStatus == 4 || raceStatus == 8){
+                raceFinished = true;
+                raceStarted = false;
                 System.out.println("RACE HAS FINISHED");
             } else if (!raceStarted){
                 raceStarted = true;
+                raceFinished = false;
                 System.out.println("RACE HAS STARTED");
             }
             if (timeTillStart % 10 == 0){
-                //System.out.println("Time since start: " + -1 * timeTillStart + " Seconds");
+                System.out.println("Time since start: " + -1 * timeTillStart + " Seconds");
+                timeSinceStart = timeTillStart;
             }
         }
         long windDir = bytesToLong(Arrays.copyOfRange(payload,18,20));
@@ -184,7 +190,6 @@ public class StreamParser extends Thread{
             boatStatus += "\nEstTimeAtNextMark: " + extractTimeStamp(Arrays.copyOfRange(payload,31 + (i * 20),37+ (i * 20)), 6);
             boatStatus += "\nEstTimeAtFinish: " + extractTimeStamp(Arrays.copyOfRange(payload,37 + (i * 20),43+ (i * 20)), 6);
             boatStatuses.add(boatStatus);
-//            System.out.println("boatStatus = " + boatStatus);
         }
     }
 
@@ -228,19 +233,25 @@ public class StreamParser extends Thread{
         //Converts XML message to string to be parsed
         int currentChar;
         while (payloadStream.available() > 0 && (currentChar = payloadStream.read()) != 0) {
-        xmlMessage += (char)currentChar;
+            xmlMessage += (char)currentChar;
+        }
+
+        // Parse boat xml from server
+        if (xmlMessageSubType == 7) {
+            BoatsParser boatsParser = new BoatsParser(xmlMessage);
+            boats = boatsParser.getBoats();
         }
 
         //Create XML document Object
-        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
-        DocumentBuilder db = null;
-        try {
-            db = dbf.newDocumentBuilder();
-            Document doc = db.parse(new InputSource(new StringReader(xmlMessage)));
-            // TODO: 25/04/17 ajm412: Check that the object matches expected structure and return Document object.
-        } catch (ParserConfigurationException | IOException | SAXException e) {
-            e.printStackTrace();
-        }
+//        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+//        DocumentBuilder db = null;
+//        try {
+//            db = dbf.newDocumentBuilder();
+//            Document doc = db.parse(new InputSource(new StringReader(xmlMessage)));
+//            // TODO: 25/04/17 ajm412: Check that the object matches expected structure and return Document object.
+//        } catch (ParserConfigurationException | IOException | SAXException e) {
+//            e.printStackTrace();
+//        }
 
     }
 
@@ -417,5 +428,50 @@ public class StreamParser extends Thread{
         }
         return partialLong;
     }
+
+    /**
+     * returns false if race not started, true otherwise
+     *
+     * @return race started status
+     */
+    public static boolean isRaceStarted() {
+        return raceStarted;
+    }
+
+    /**
+     * returns false if stream not connected, true otherwise
+     *
+     * @return stream started status
+     */
+    public static boolean isStreamStatus() {
+        return streamStatus;
+    }
+
+    /**
+     * returns race timer
+     *
+     * @return race timer in long
+     */
+    public static long getTimeSinceStart() {
+        return timeSinceStart;
+    }
+
+    /**
+     * return false if race not finished, true otherwise
+     *
+     * @return race finished status
+     */
+    public static boolean isRaceFinished() {
+        return raceFinished;
+    }
+
+    /**
+     * return list of boats from the server
+     *
+     * @return list of boats
+     */
+    public static List<Boat> getBoats() {
+        return boats;
+    }
 }
 

src/main/java/seng302/models/parsers/StreamReceiver.java

@@ -6,6 +6,8 @@ import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.Socket;
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Comparator;
 import java.util.concurrent.PriorityBlockingQueue;
 import java.util.zip.CRC32;
@@ -15,8 +17,8 @@ import java.util.zip.Checksum;
 public class StreamReceiver extends Thread {
     private InputStream stream;
     private Socket host;
-    private ByteArrayOutputStream crcBuffer;
-    private Thread thread;
+    private  ByteArrayOutputStream crcBuffer;
+    private Thread t;
     private String threadName;
     public static PriorityBlockingQueue<StreamPacket> packetBuffer;
 
@@ -31,24 +33,31 @@ public class StreamReceiver extends Thread {
     }
 
     public void run(){
-        packetBuffer = new PriorityBlockingQueue<>(256, new Comparator<StreamPacket>() {
+        PriorityBlockingQueue<StreamPacket> pq = new PriorityBlockingQueue<>(256, new Comparator<StreamPacket>() {
             @Override
             public int compare(StreamPacket s1, StreamPacket s2) {
                 return (int) (s1.getTimeStamp() - s2.getTimeStamp());
             }
         });
+        packetBuffer = pq;
         connect();
     }
 
     public void start () {
         System.out.println("Starting " +  threadName );
-        if (thread == null) {
-            thread = new Thread (this, threadName);
-            thread.start ();
+        if (t == null) {
+            t = new Thread (this, threadName);
+            t.start ();
         }
     }
 
 
+    public StreamReceiver(Socket host,  PriorityBlockingQueue packetBuffer){
+        this.host=host;
+        this.packetBuffer = packetBuffer;
+    }
+
+
     public void connect(){
         try {
             stream = host.getInputStream();
@@ -120,8 +129,8 @@ public class StreamReceiver extends Thread {
     }
 
     /**
-     * takes an array of up to 7 bytes and returns a positive
-     * long constructed from the input bytes
+     * takes an array of up to 7 bytes in little endian format and
+     * returns a positive long constructed from the input bytes
      *
      * @return a positive long if there is less than 8 bytes -1 otherwise
      */
@@ -137,4 +146,13 @@ public class StreamReceiver extends Thread {
         }
         return partialLong;
     }
+
+
+    public static void main(String[] args) {
+
+        StreamReceiver sr = new StreamReceiver("csse-s302staff.canterbury.ac.nz", 4941,"TestThread1");
+        //StreamReceiver sr = new StreamReceiver("livedata.americascup.com", 4941, "TestThread2");
+        sr.start();
+
+    }
 }

src/main/java/seng302/models/parsers/XMLParser.java

@@ -0,0 +1,461 @@
+package seng302.models.parsers;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+import java.util.ArrayList;
+
+/**
+ * Class to create an XML object from the XML Packet Messages.
+ */
+class XMLParser {
+
+    /**
+     * Creates a Regatta XML Object from the data in a Regatta XML Message
+     * @param doc XML Document Object
+     * @return A new RegattaXMLObject from the input Document.
+     */
+    RegattaXMLObject createRegattaXML(Document doc) {
+        return new RegattaXMLObject(doc);
+    }
+
+    /**
+     * Creates a Race XML Object from the data in a Regatta XML Message
+     * @param doc XML Document Object
+     * @return A new RaceXMLObject from the input Document.
+     */
+    RaceXMLObject createRaceXML(Document doc) {
+        return new RaceXMLObject(doc);
+    }
+
+    /**
+     * Creates a Boat XML Object from the data in a Regatta XML Message
+     * @param doc XML Document Object
+     * @return A new BoatXMLObject from the input Document.
+     */
+    BoatXMLObject createBoatXML(Document doc) {
+        return new BoatXMLObject(doc);
+    }
+
+    /**
+     * Returns the text content of a given child element tag, assuming it exists, as an Integer.
+     * @param ele Document Element with child elements.
+     * @param tag Tag to find in document elements child elements.
+     * @return Text content from tag if found, null otherwise.
+     */
+    private static Integer getElementInt(Element ele, String tag) {
+        NodeList tagList = ele.getElementsByTagName(tag);
+        if (tagList.getLength() > 0) {
+            return Integer.parseInt(tagList.item(0).getTextContent());
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the text content of a given child element tag, assuming it exists, as an String.
+     * @param ele Document Element with child elements.
+     * @param tag Tag to find in document elements child elements.
+     * @return Text content from tag if found, null otherwise.
+     */
+    private static String getElementString(Element ele, String tag) {
+        NodeList tagList = ele.getElementsByTagName(tag);
+        if (tagList.getLength() > 0) {
+            return tagList.item(0).getTextContent();
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the text content of a given child element tag, assuming it exists, as a Double.
+     * @param ele Document Element with child elements.
+     * @param tag Tag to find in document elements child elements.
+     * @return Text content from tag if found, null otherwise.
+     */
+    private static Double getElementDouble(Element ele, String tag) {
+        NodeList tagList = ele.getElementsByTagName(tag);
+        if (tagList.getLength() > 0) {
+            return Double.parseDouble(tagList.item(0).getTextContent());
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the text content of an attribute of a given Node, assuming it exists, as a String.
+     * @param n A node object that should have some attributes
+     * @param attr The attribute you want to get from the given node.
+     * @return The String representation of the text content of an attribute in the given node, else returns null.
+     */
+    private static String getNodeAttributeString(Node n, String attr) {
+        Node attrItem = n.getAttributes().getNamedItem(attr);
+        if (attrItem != null) {
+            return attrItem.getTextContent();
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the text content of an attribute of a given Node, assuming it exists, as an Integer.
+     * @param n A node object that should have some attributes
+     * @param attr The attribute you want to get from the given node.
+     * @return The Integer representation of the text content of an attribute in the given node, else returns null.
+     */
+    private static Integer getNodeAttributeInt(Node n, String attr) {
+        Node attrItem = n.getAttributes().getNamedItem(attr);
+        if (attrItem != null) {
+            return Integer.parseInt(attrItem.getTextContent());
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Returns the text content of an attribute of a given Node, assuming it exists, as a Double.
+     * @param n A node object that should have some attributes
+     * @param attr The attribute you want to get from the given node.
+     * @return The Double representation of the text content of an attribute in the given node, else returns null.
+     */
+    private static Double getNodeAttributeDouble(Node n, String attr) {
+        Node attrItem = n.getAttributes().getNamedItem(attr);
+        if (attrItem != null) {
+            return Double.parseDouble(attrItem.getTextContent());
+        } else {
+            return null;
+        }
+    }
+
+    class RegattaXMLObject {
+        //Regatta Info
+        private Integer regattaID;
+        private String regattaName;
+        private String courseName;
+        private Double centralLat;
+        private Double centralLng;
+        private Integer utcOffset;
+
+        /**
+         * Constructor for a RegattaXMLObject.
+         * Takes the information from a Document object and creates a more usable format.
+         * @param doc XML Document Object
+         */
+        RegattaXMLObject(Document doc) {
+            Element docEle = doc.getDocumentElement();
+
+            this.regattaID = getElementInt(docEle, "RegattaID");
+            this.regattaName = getElementString(docEle, "RegattaName");
+            this.courseName = getElementString(docEle, "CourseName");
+            this.centralLat = getElementDouble(docEle, "CentralLatitude");
+            this.centralLng = getElementDouble(docEle, "CentralLongitude");
+            this.utcOffset = getElementInt(docEle, "UtcOffset");
+        }
+
+        public Integer getRegattaID() { return regattaID; }
+        public String getRegattaName() { return regattaName; }
+        public String getCourseName() { return courseName; }
+        public Double getCentralLat() { return centralLat; }
+        public Double getCentralLng() { return centralLng; }
+        public Integer getUtcOffset() { return utcOffset; }
+
+    }
+
+    class RaceXMLObject {
+
+        // Race Info
+        private Integer raceID;
+        private String raceType;
+        private String creationTimeDate; // XML Creation Time
+
+        //Race Start Details
+        private String raceStartTime;
+        private Boolean postponeStatus;
+
+        //Non atomic race attributes
+        private ArrayList<Participant> participants;
+        private ArrayList<CompoundMark> course;
+        private ArrayList<Corner> compoundMarkSequence;
+        private ArrayList<Limit> courseLimit;
+
+        /**
+         * Constructor for a RaceXMLObject.
+         * Takes the information from a Document object and creates a more usable format.
+         * @param doc XML Document Object
+         */
+        RaceXMLObject(Document doc) {
+            Element docEle = doc.getDocumentElement();
+
+            //Atomic and Semi-Atomic Elements
+            this.raceID = getElementInt(docEle, "RaceID");
+            this.raceType = getElementString(docEle, "RaceType");
+            this.creationTimeDate = getElementString(docEle, "CreationTimeDate");
+
+            Node raceStart = docEle.getElementsByTagName("RaceStartTime").item(0);
+            this.raceStartTime = getNodeAttributeString(raceStart, "Start") ;
+            this.postponeStatus = Boolean.parseBoolean(getNodeAttributeString(raceStart, "Postpone"));
+
+            //Participants
+            participants = new ArrayList<>();
+
+            NodeList pList = docEle.getElementsByTagName("Participants").item(0).getChildNodes();
+            for (int i = 0; i < pList.getLength(); i++) {
+                Node pNode = pList.item(i);
+                String entry;
+                if (pNode.getNodeName().equals("Yacht")) {
+                    Integer sourceID = getNodeAttributeInt(pNode, "SourceID");
+
+                    if (pNode.getAttributes().getLength() == 2) {
+                        entry = getNodeAttributeString(pNode, "Entry");
+                    } else {
+                        entry = null;
+                    }
+
+                    Participant pa = new Participant(sourceID, entry);
+                    participants.add(pa);
+                }
+            }
+
+            //Course
+            course = new ArrayList<>();
+
+            NodeList cMarkList = docEle.getElementsByTagName("Course").item(0).getChildNodes();
+            for (int i = 0; i < cMarkList.getLength(); i++) {
+                Node cMarkNode = cMarkList.item(i);
+                if (cMarkNode.getNodeName().equals("CompoundMark")) {
+                    CompoundMark cMark = new CompoundMark(cMarkNode);
+                    course.add(cMark);
+                }
+            }
+
+            //Course Mark Sequence
+            compoundMarkSequence = new ArrayList<>();
+
+            NodeList cornerList = docEle.getElementsByTagName("CompoundMarkSequence").item(0).getChildNodes();
+            for (int i = 0; i < cornerList.getLength(); i++) {
+                Node cornerNode = cornerList.item(i);
+                if (cornerNode.getNodeName().equals("Corner")) {
+                    Corner corner = new Corner(cornerNode);
+                    compoundMarkSequence.add(corner);
+                }
+            }
+
+            //Course Limits
+            courseLimit = new ArrayList<>();
+
+            NodeList limitList = docEle.getElementsByTagName("CourseLimit").item(0).getChildNodes();
+            for (int i = 0; i < limitList.getLength(); i++) {
+                Node limitNode = limitList.item(i);
+                if (limitNode.getNodeName().equals("Limit")) {
+                    Limit limit = new Limit(limitNode);
+                    courseLimit.add(limit);
+                }
+            }
+        }
+
+        public Integer getRaceID() { return raceID; }
+        public String getRaceType() { return raceType; }
+        public String getCreationTimeDate() { return creationTimeDate; }
+        public String getRaceStartTime() { return raceStartTime; }
+        public Boolean getPostponeStatus() { return postponeStatus; }
+
+        public ArrayList<Participant> getParticipants() { return participants; }
+        public ArrayList<CompoundMark> getCompoundMarks() { return course; }
+        public ArrayList<Corner> getCompoundMarkSequence() { return compoundMarkSequence; }
+        public ArrayList<Limit> getCourseLimit() { return courseLimit; }
+
+        class Participant {
+            Integer sourceID;
+            String entry;
+
+            Participant(Integer sourceID, String entry) {
+                this.sourceID = sourceID;
+                this.entry = entry;
+            }
+
+            public Integer getsourceID() { return sourceID; }
+            public String getEntry() { return entry; }
+        }
+
+        class CompoundMark {
+            private Integer markID;
+            private String cMarkName;
+            private ArrayList<Mark> marks;
+
+            CompoundMark(Node compoundMark) {
+                marks = new ArrayList<>();
+                this.markID = getNodeAttributeInt(compoundMark, "CompoundMarkID");
+                this.cMarkName = getNodeAttributeString(compoundMark, "Name");
+                NodeList childMarks = compoundMark.getChildNodes();
+                for (int i = 0; i < childMarks.getLength(); i++) {
+                    Node markNode = childMarks.item(i);
+                    if (markNode.getNodeName().equals("Mark")) {
+                        Mark mark = new Mark(markNode);
+                        marks.add(mark);
+                    }
+                }
+            }
+
+            public Integer getMarkID() { return markID; }
+            public String getcMarkName() { return cMarkName; }
+            public ArrayList<Mark> getMarks() { return marks; }
+
+            class Mark {
+                private Integer seqID;
+                private Integer sourceID;
+                private String markName;
+                private Double targetLat;
+                private Double targetLng;
+
+                Mark(Node markNode) {
+
+                    this.seqID = getNodeAttributeInt(markNode, "SeqID");
+                    this.sourceID = getNodeAttributeInt(markNode, "SourceID");
+                    this.markName = getNodeAttributeString(markNode, "Name");
+                    this.targetLat = getNodeAttributeDouble(markNode, "TargetLat");
+                    this.targetLng = getNodeAttributeDouble(markNode, "TargetLng");
+
+                }
+
+                public Integer getSeqID() { return seqID; }
+                public Integer getSourceID() { return sourceID; }
+                public String getMarkName() { return markName; }
+                public Double getTargetLat() { return targetLat; }
+                public Double getTargetLng() { return targetLng; }
+            }
+        }
+
+        class Corner {
+            private Integer seqID;
+            private Integer compoundMarkID;
+            private String rounding;
+            private Integer zoneSize;
+
+            Corner(Node cornerNode) {
+                this.seqID = getNodeAttributeInt(cornerNode, "SeqID");
+                this.compoundMarkID = getNodeAttributeInt(cornerNode, "CompoundMarkID");
+                this.rounding = getNodeAttributeString(cornerNode, "Rounding");
+                this.zoneSize = getNodeAttributeInt(cornerNode, "ZoneSize");
+            }
+
+            public Integer getSeqID() { return seqID; }
+            public Integer getCompoundMarkID() { return compoundMarkID; }
+            public String getRounding() { return rounding; }
+            public Integer getZoneSize() { return zoneSize; }
+        }
+
+        class Limit {
+            private Integer seqID;
+            private Double lat;
+            private Double lng;
+
+            Limit(Node limitNode) {
+                this.seqID = getNodeAttributeInt(limitNode, "SeqID");
+                this.lat = getNodeAttributeDouble(limitNode, "Lat");
+                this.lng = getNodeAttributeDouble(limitNode, "Lon");
+            }
+
+            public Integer getSeqID() { return seqID; }
+            public Double getLat() { return lat; }
+            public Double getLng() { return lng; }
+        }
+
+    }
+
+    class BoatXMLObject {
+
+        private String lastModified;
+        private Integer version;
+
+        //Settings for the boat type in the race. This may end up having to be reworked if multiple boat types compete.
+        private String boatType;
+        private Double boatLength;
+        private Double hullLength;
+        private Double markZoneSize;
+        private Double courseZoneSize;
+        private ArrayList<Double> zoneLimits;// will only contain 5 elements. Limits 1-5
+
+        //Boats
+        ArrayList<Boat> boats;
+
+        /**
+         * Constructor for a BoatXMLObject.
+         * Takes the information from a Document object and creates a more usable format.
+         * @param doc XML Document Object
+         */
+        BoatXMLObject(Document doc) {
+
+            Element docEle = doc.getDocumentElement();
+
+            this.lastModified = getElementString(docEle, "Modified");
+            this.version = getElementInt(docEle, "Version");
+
+            NodeList settingsList = docEle.getElementsByTagName("Settings").item(0).getChildNodes();
+            this.boatType = getNodeAttributeString(settingsList.item(1), "Type");
+            this.boatLength = getNodeAttributeDouble(settingsList.item(3), "BoatLength");
+            this.hullLength = getNodeAttributeDouble(settingsList.item(3), "HullLength");
+            this.markZoneSize = getNodeAttributeDouble(settingsList.item(5), "MarkZoneSize");
+            this.courseZoneSize = getNodeAttributeDouble(settingsList.item(5), "CourseZoneSize");
+
+            Node zoneLimitsList = settingsList.item(7);
+            this.zoneLimits = new ArrayList<>();
+            for (int i = 0; i < zoneLimitsList.getAttributes().getLength(); i++) {
+                String tag = String.format("Limit%d", i+1);
+                this.zoneLimits.add(getNodeAttributeDouble(zoneLimitsList, tag));
+            }
+
+            this.boats = new ArrayList<>();
+            NodeList boatsList = docEle.getElementsByTagName("Boats").item(0).getChildNodes();
+            for (int i = 0; i < boatsList.getLength(); i++) {
+                Node currentBoat = boatsList.item(i);
+                if (currentBoat.getNodeName().equals("Boat")) {
+                    Boat boat = new Boat(currentBoat);
+                    this.boats.add(boat);
+                }
+                //System.out.println(this.getBoats());
+            }
+
+        }
+
+        public String getLastModified() { return lastModified; }
+        public Integer getVersion() { return version; }
+        public String getBoatType() { return boatType; }
+        public Double getBoatLength() { return boatLength; }
+        public Double getHullLength() { return hullLength; }
+        public Double getMarkZoneSize() { return markZoneSize; }
+        public Double getCourseZoneSize() { return courseZoneSize; }
+        public ArrayList<Double> getZoneLimits() { return zoneLimits; }
+        public ArrayList<Boat> getBoats() { return boats; }
+
+        class Boat {
+
+            private String boatType;
+            private Integer sourceID;
+            private String hullID; //matches HullNum in the XML spec.
+            private String shortName;
+            private String boatName;
+            private String country;
+
+            Boat(Node boatNode) {
+                this.boatType = getNodeAttributeString(boatNode, "Type");
+                this.sourceID = getNodeAttributeInt(boatNode, "SourceID");
+                this.hullID = getNodeAttributeString(boatNode, "HullNum");
+                this.shortName = getNodeAttributeString(boatNode, "ShortName");
+                this.boatName = getNodeAttributeString(boatNode, "BoatName");
+                this.country = getNodeAttributeString(boatNode, "Country");
+            }
+
+            public String getBoatType() { return boatType; }
+            public Integer getSourceID() { return sourceID; }
+            public String getHullID() { return hullID; }
+            public String getShortName() { return shortName; }
+            public String getBoatName() { return boatName; }
+            public String getCountry() { return country; }
+
+        }
+
+    }
+
+}