You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
289 lines
11 KiB
289 lines
11 KiB
package seng302.DataInput;
|
|
|
|
import org.w3c.dom.Element;
|
|
import org.w3c.dom.NamedNodeMap;
|
|
import org.w3c.dom.Node;
|
|
import org.w3c.dom.NodeList;
|
|
import org.xml.sax.SAXException;
|
|
import seng302.Exceptions.StreamedCourseXMLException;
|
|
import seng302.Model.*;
|
|
|
|
import javax.xml.parsers.ParserConfigurationException;
|
|
import java.io.IOException;
|
|
import java.text.ParseException;
|
|
import java.time.ZonedDateTime;
|
|
import java.time.format.DateTimeFormatter;
|
|
import java.util.*;
|
|
|
|
/**
|
|
* XML Reader that reads in the race data required for this race
|
|
*/
|
|
public class RaceXMLReader extends XMLReader implements RaceDataSource {
|
|
private static final double COORDINATEPADDING = 0.000;
|
|
private GPSCoordinate mapTopLeft, mapBottomRight;
|
|
private final List<GPSCoordinate> boundary = new ArrayList<>();
|
|
private final Map<Integer,Element> compoundMarkMap = new HashMap<>();
|
|
private final Map<Integer, Boat> participants = new HashMap<>();
|
|
private final List<Leg> legs = new ArrayList<>();
|
|
private final List<CompoundMark> compoundMarks = new ArrayList<>();
|
|
private ZonedDateTime creationTimeDate;
|
|
private ZonedDateTime raceStartTime;
|
|
private int raceID;
|
|
private String raceType;
|
|
private boolean postpone;
|
|
|
|
private Map<Integer, Boat> boats;
|
|
private Map<Integer, Mark> marks;
|
|
|
|
/**
|
|
* Constructor for Streamed Race XML
|
|
* @param filePath path of the file
|
|
* @param boatData data for boats in race
|
|
* @throws IOException error
|
|
* @throws SAXException error
|
|
* @throws ParserConfigurationException error
|
|
* @throws ParseException error
|
|
* @throws StreamedCourseXMLException error
|
|
*/
|
|
public RaceXMLReader(String filePath, BoatDataSource boatData) throws IOException, SAXException, ParserConfigurationException, ParseException, StreamedCourseXMLException {
|
|
this(filePath, boatData, true);
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Constructor for Streamed Race XML
|
|
* @param filePath file path to read
|
|
* @param boatData data of the boats in race
|
|
* @param read whether or not to read and store the files straight away.
|
|
* @throws IOException error
|
|
* @throws SAXException error
|
|
* @throws ParserConfigurationException error
|
|
* @throws ParseException error
|
|
* @throws StreamedCourseXMLException error
|
|
*/
|
|
public RaceXMLReader(String filePath, BoatDataSource boatData, boolean read) throws IOException, SAXException, ParserConfigurationException, ParseException, StreamedCourseXMLException {
|
|
super(filePath);
|
|
this.boats = boatData.getBoats();
|
|
this.marks = boatData.getMarkerBoats();
|
|
if (read) {
|
|
read();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* reads
|
|
* @throws StreamedCourseXMLException error
|
|
*/
|
|
private void read() throws StreamedCourseXMLException {
|
|
readRace();
|
|
readParticipants();
|
|
readCourse();
|
|
}
|
|
|
|
/**
|
|
* reads a race
|
|
*/
|
|
private void readRace() {
|
|
DateTimeFormatter dateFormat = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
|
|
Element settings = (Element) doc.getElementsByTagName("Race").item(0);
|
|
NamedNodeMap raceTimeTag = doc.getElementsByTagName("RaceStartTime").item(0).getAttributes();
|
|
|
|
if (raceTimeTag.getNamedItem("Time") != null) dateFormat = DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssZ");
|
|
|
|
|
|
raceID = Integer.parseInt(getTextValueOfNode(settings, "RaceID"));
|
|
raceType = getTextValueOfNode(settings, "RaceType");
|
|
|
|
creationTimeDate = ZonedDateTime.parse(getTextValueOfNode(settings, "CreationTimeDate"), dateFormat);
|
|
|
|
if (raceTimeTag.getNamedItem("Time") != null) raceStartTime = ZonedDateTime.parse(raceTimeTag.getNamedItem("Time").getTextContent(), dateFormat);
|
|
else raceStartTime = ZonedDateTime.parse(raceTimeTag.getNamedItem("Start").getTextContent(), dateFormat);
|
|
|
|
postpone = Boolean.parseBoolean(raceTimeTag.getNamedItem("Postpone").getTextContent());
|
|
}
|
|
|
|
/**
|
|
* Reads in the participants for htis race
|
|
*/
|
|
private void readParticipants() {
|
|
Element nParticipants = (Element) doc.getElementsByTagName("Participants").item(0);
|
|
nParticipants.getChildNodes().getLength();
|
|
for (int i = 0; i < nParticipants.getChildNodes().getLength(); i++) {
|
|
int sourceID;
|
|
Node yacht = nParticipants.getChildNodes().item(i);
|
|
if (yacht.getNodeName().equals("Yacht")) {
|
|
if (exists(yacht, "SourceID")) {
|
|
sourceID = Integer.parseInt(yacht.getAttributes().getNamedItem("SourceID").getTextContent());
|
|
participants.put(sourceID, boats.get(sourceID));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* reads a course
|
|
* @throws StreamedCourseXMLException error
|
|
*/
|
|
private void readCourse() throws StreamedCourseXMLException {
|
|
readCompoundMarks();
|
|
readCompoundMarkSequence();
|
|
readCourseLimit();
|
|
}
|
|
|
|
/**
|
|
* Indexes CompoundMark elements by their ID for use in generating the course, and populates list of Markers.
|
|
* @see CompoundMark
|
|
*/
|
|
private void readCompoundMarks() throws StreamedCourseXMLException {
|
|
Element nCourse = (Element) doc.getElementsByTagName("Course").item(0);
|
|
for(int i = 0; i < nCourse.getChildNodes().getLength(); i++) {
|
|
Node compoundMark = nCourse.getChildNodes().item(i);
|
|
if(compoundMark.getNodeName().equals("CompoundMark")) {
|
|
int compoundMarkID = getCompoundMarkID((Element) compoundMark);
|
|
compoundMarkMap.put(compoundMarkID, (Element)compoundMark);
|
|
compoundMarks.add(getCompoundMark(compoundMarkID));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Generates a CompoundMark from the CompoundMark element with given ID.
|
|
* @param compoundMarkID index of required CompoundMark element
|
|
* @return generated CompoundMark
|
|
* @throws StreamedCourseXMLException if CompoundMark element contains unhandled number of compoundMarks
|
|
* @see CompoundMark
|
|
*/
|
|
private CompoundMark getCompoundMark(int compoundMarkID) throws StreamedCourseXMLException {
|
|
Element compoundMark = compoundMarkMap.get(compoundMarkID);
|
|
NodeList nMarks = compoundMark.getElementsByTagName("Mark");
|
|
CompoundMark marker;
|
|
|
|
switch(nMarks.getLength()) {
|
|
case 1: marker = new CompoundMark(getMark((Element)nMarks.item(0)));
|
|
break;
|
|
case 2: marker = new CompoundMark(getMark((Element)nMarks.item(0)), getMark((Element)nMarks.item(1))); break;
|
|
default: throw new StreamedCourseXMLException();
|
|
}
|
|
|
|
return marker;
|
|
}
|
|
|
|
/**
|
|
* Gets a mark from an Element
|
|
* @param mark Element the mark is suppose to be part of
|
|
* @return a Mark that existed in the element
|
|
*/
|
|
private Mark getMark(Element mark) {
|
|
int sourceID = Integer.parseInt(mark.getAttribute("SourceID"));
|
|
return marks.get(sourceID);
|
|
}
|
|
|
|
/**
|
|
* Reads "compoundMarkID" attribute of CompoundMark or Corner element
|
|
* @param element with "compoundMarkID" attribute
|
|
* @return value of "compoundMarkID" attribute
|
|
*/
|
|
private int getCompoundMarkID(Element element) {
|
|
return Integer.parseInt(element.getAttribute("CompoundMarkID"));
|
|
}
|
|
|
|
/**
|
|
* Reads "name" attribute of CompoundMark element with corresponding CompoundMarkID
|
|
* @param compoundMarkID unique ID for CompoundMark element
|
|
* @return value of "name" attribute
|
|
*/
|
|
private String getCompoundMarkName(int compoundMarkID) {
|
|
return compoundMarkMap.get(compoundMarkID).getAttribute("Name");
|
|
}
|
|
|
|
/**
|
|
* Populates list of legs given CompoundMarkSequence element and referenced CompoundMark elements.
|
|
* @throws StreamedCourseXMLException if compoundMarks cannot be resolved from CompoundMark
|
|
*/
|
|
private void readCompoundMarkSequence() throws StreamedCourseXMLException {
|
|
Element nCompoundMarkSequence = (Element) doc.getElementsByTagName("CompoundMarkSequence").item(0);
|
|
NodeList nCorners = nCompoundMarkSequence.getElementsByTagName("Corner");
|
|
Element markXML = (Element)nCorners.item(0);
|
|
CompoundMark lastCompoundMark = getCompoundMark(getCompoundMarkID(markXML));
|
|
String legName = getCompoundMarkName(getCompoundMarkID(markXML));
|
|
for(int i = 1; i < nCorners.getLength(); i++) {
|
|
markXML = (Element)nCorners.item(i);
|
|
CompoundMark currentCompoundMark = getCompoundMark(getCompoundMarkID(markXML));
|
|
legs.add(new Leg(legName, lastCompoundMark, currentCompoundMark, i-1));
|
|
lastCompoundMark = currentCompoundMark;
|
|
legName = getCompoundMarkName(getCompoundMarkID(markXML));
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Reads the boundary limits of the course
|
|
*/
|
|
private void readCourseLimit() {
|
|
Element nCourseLimit = (Element) doc.getElementsByTagName("CourseLimit").item(0);
|
|
for(int i = 0; i < nCourseLimit.getChildNodes().getLength(); i++) {
|
|
Node limit = nCourseLimit.getChildNodes().item(i);
|
|
if (limit.getNodeName().equals("Limit")) {
|
|
double lat = Double.parseDouble(limit.getAttributes().getNamedItem("Lat").getTextContent());
|
|
double lon = Double.parseDouble(limit.getAttributes().getNamedItem("Lon").getTextContent());
|
|
boundary.add(new GPSCoordinate(lat, lon));
|
|
}
|
|
}
|
|
|
|
double maxLatitude = boundary.stream().max(Comparator.comparingDouble(GPSCoordinate::getLatitude)).get().getLatitude() + COORDINATEPADDING;
|
|
double maxLongitude = boundary.stream().max(Comparator.comparingDouble(GPSCoordinate::getLongitude)).get().getLongitude() + COORDINATEPADDING;
|
|
double minLatitude = boundary.stream().min(Comparator.comparingDouble(GPSCoordinate::getLatitude)).get().getLatitude() + COORDINATEPADDING;
|
|
double minLongitude = boundary.stream().min(Comparator.comparingDouble(GPSCoordinate::getLongitude)).get().getLongitude() + COORDINATEPADDING;
|
|
|
|
mapTopLeft = new GPSCoordinate(minLatitude, minLongitude);
|
|
mapBottomRight = new GPSCoordinate(maxLatitude, maxLongitude);
|
|
}
|
|
|
|
public List<GPSCoordinate> getBoundary() {
|
|
return boundary;
|
|
}
|
|
|
|
public GPSCoordinate getMapTopLeft() {
|
|
return mapTopLeft;
|
|
}
|
|
|
|
public GPSCoordinate getMapBottomRight() {
|
|
return mapBottomRight;
|
|
}
|
|
|
|
public List<Leg> getLegs() {
|
|
return legs;
|
|
}
|
|
|
|
public List<CompoundMark> getCompoundMarks() { return compoundMarks; }
|
|
|
|
public Double getPadding() {
|
|
return COORDINATEPADDING;
|
|
}
|
|
|
|
public ZonedDateTime getCreationTimeDate() {
|
|
return creationTimeDate;
|
|
}
|
|
|
|
public ZonedDateTime getZonedDateTime() {
|
|
return raceStartTime;
|
|
}
|
|
|
|
public int getRaceId() {
|
|
return raceID;
|
|
}
|
|
|
|
public String getRaceType() {
|
|
return raceType;
|
|
}
|
|
|
|
public boolean isPostpone() {
|
|
return postpone;
|
|
}
|
|
|
|
public List<Boat> getBoats() {
|
|
return new ArrayList<>(participants.values());
|
|
}
|
|
}
|