TDMParser.java

  1. /* Copyright 2002-2018 CS Systèmes d'Information
  2.  * Licensed to CS Systèmes d'Information (CS) under one or more
  3.  * contributor license agreements.  See the NOTICE file distributed with
  4.  * this work for additional information regarding copyright ownership.
  5.  * CS licenses this file to You under the Apache License, Version 2.0
  6.  * (the "License"); you may not use this file except in compliance with
  7.  * the License.  You may obtain a copy of the License at
  8.  *
  9.  *   http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.orekit.files.ccsds;

  19. import java.io.BufferedReader;
  20. import java.io.FileInputStream;
  21. import java.io.IOException;
  22. import java.io.InputStream;
  23. import java.io.InputStreamReader;
  24. import java.util.ArrayList;
  25. import java.util.List;

  27. import javax.xml.parsers.ParserConfigurationException;
  28. import javax.xml.parsers.SAXParser;
  29. import javax.xml.parsers.SAXParserFactory;

  31. import org.hipparchus.exception.DummyLocalizable;
  32. import org.orekit.errors.OrekitException;
  33. import org.orekit.errors.OrekitMessages;
  34. import org.orekit.time.AbsoluteDate;
  35. import org.orekit.time.TimeScalesFactory;
  36. import org.orekit.utils.IERSConventions;
  37. import org.xml.sax.Attributes;
  38. import org.xml.sax.InputSource;
  39. import org.xml.sax.Locator;
  40. import org.xml.sax.SAXException;
  41. import org.xml.sax.helpers.DefaultHandler;


  44. /**
  45.  * Class for CCSDS Tracking Data Message parsers.
  46.  *
  47.  * <p> This base class is immutable, and hence thread safe. When parts must be
  48.  * changed, such as reference date for Mission Elapsed Time or Mission Relative
  49.  * Time time systems, or the gravitational coefficient or the IERS conventions,
  50.  * the various {@code withXxx} methods must be called, which create a new
  51.  * immutable instance with the new parameters. This is a combination of the <a
  52.  * href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  53.  * pattern</a> and a <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  54.  * interface</a>.
  55.  *
  56.  * <p> This class allow the handling of both "keyvalue" and "xml" TDM file formats.
  57.  * Format can be inferred if file names ends respectively with ".txt" or ".xml".
  58.  * Otherwise it must be explicitely set using {@link #withFileFormat(TDMFileFormat)}
  59.  *
  60.  * <p>ParseInfo subclass regroups common parsing functions; and specific handlers were added
  61.  * for both file formats.
  62.  *
  63.  * <p>References:<p>
  64.  *  - <a href="https://public.ccsds.org/Pubs/503x0b1c1.pdf">CCSDS 503.0-B-1 recommended standard</a> ("Tracking Data Message", Blue Book, Issue 1, November 2007).<p>
  65.  *  - <a href="https://public.ccsds.org/Pubs/505x0b1.pdf">CCSDS 505.0-B-1 recommended standard</a> ("XML Specification for Navigation Data Message", Blue Book, Issue 1, December 2010).<p>
  66.  *
  67.  * @author Maxime Journot
  68.  * @since 9.0
  69.  */
  70. public class TDMParser extends DefaultHandler {

  72.     /** Enumerate for the format. */
  73.     public enum TDMFileFormat {

  75.         /** Keyvalue (text file with Key = Value lines). */
  76.         KEYVALUE,

  78.         /** XML format. */
  79.         XML,

  81.         /** UKNOWN file format, default format, throw an Orekit Exception if kept this way. */
  82.         UNKNOWN;
  83.     }

  85.     /** Format of the file to parse: KEYVALUE or XML. */
  86.     private TDMFileFormat fileFormat;

  88.     /** Reference date for Mission Elapsed Time or Mission Relative Time time systems. */
  89.     private final AbsoluteDate missionReferenceDate;

  91.     /** IERS Conventions. */
  92.     private final  IERSConventions conventions;

  94.     /** Indicator for simple or accurate EOP interpolation. */
  95.     private final  boolean simpleEOP;

  97.     /** Simple constructor.
  98.      * <p>
  99.      * This class is immutable, and hence thread safe. When parts
  100.      * must be changed, such fiel format or reference date for Mission Elapsed Time or
  101.      * Mission Relative Time time systems, or the IERS conventions,
  102.      * the various {@code withXxx} methods must be called,
  103.      * which create a new immutable instance with the new parameters. This
  104.      * is a combination of the
  105.      * <a href="https://en.wikipedia.org/wiki/Builder_pattern">builder design
  106.      * pattern</a> and a
  107.      * <a href="http://en.wikipedia.org/wiki/Fluent_interface">fluent
  108.      * interface</a>.
  109.      * </p>
  110.      * <p>
  111.      * The initial date for Mission Elapsed Time and Mission Relative Time time systems is not set here.
  112.      * If such time systems are used, it must be initialized before parsing by calling {@link
  113.      * #withMissionReferenceDate(AbsoluteDate)}.
  114.      * </p>
  115.      * <p>
  116.      * The IERS conventions to use is not set here. If it is needed in order to
  117.      * parse some reference frames or UT1 time scale, it must be initialized before
  118.      * parsing by calling {@link #withConventions(IERSConventions)}.
  119.      * </p>
  120.      * <p>
  121.      * The TDM file format to use is not set here. It may be automatically inferred while parsing
  122.      * if the name of the file to parse ends with ".txt" or ".xml".
  123.      * Otherwise it must be initialized before parsing by calling {@link #withFileFormat(TDMFileFormat)}
  124.      * </p>
  125.      */
  126.     public TDMParser() {
  127.         this(TDMFileFormat.UNKNOWN, AbsoluteDate.FUTURE_INFINITY, null, true);
  128.     }

  130.     /** Complete constructor.
  131.      * @param fileFormat The format of the file: KEYVALUE or XML
  132.      * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  133.      * @param conventions IERS Conventions
  134.      * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  135.      */
  136.     private TDMParser(final TDMFileFormat fileFormat,
  137.                       final AbsoluteDate missionReferenceDate,
  138.                       final IERSConventions conventions,
  139.                       final boolean simpleEOP) {
  140.         this.fileFormat = fileFormat;
  141.         this.missionReferenceDate = missionReferenceDate;
  142.         this.conventions          = conventions;
  143.         this.simpleEOP            = simpleEOP;
  144.     }

  146.     /** Set file format.
  147.      * @param newFileFormat The format of the file: KEYVALUE or XML
  148.      * @return a new instance, with file format set to newFileFormat
  149.      * @see #getFileFormat()
  150.      */
  151.     public TDMParser withFileFormat(final TDMFileFormat newFileFormat) {
  152.         return new TDMParser(newFileFormat, getMissionReferenceDate(), getConventions(), isSimpleEOP());
  153.     }

  155.     /** Get file format.
  156.      * @return the file format
  157.      * @see #withFileFormat(TDMFileFormat)
  158.      */
  159.     public TDMFileFormat getFileFormat() {
  160.         return fileFormat;
  161.     }

  163.     /** Set initial date.
  164.      * @param newMissionReferenceDate mission reference date to use while parsing
  165.      * @return a new instance, with mission reference date replaced
  166.      * @see #getMissionReferenceDate()
  167.      */
  168.     public TDMParser withMissionReferenceDate(final AbsoluteDate newMissionReferenceDate) {
  169.         return new TDMParser(getFileFormat(), newMissionReferenceDate, getConventions(), isSimpleEOP());
  170.     }

  172.     /** Get initial date.
  173.      * @return mission reference date to use while parsing
  174.      * @see #withMissionReferenceDate(AbsoluteDate)
  175.      */
  176.     public AbsoluteDate getMissionReferenceDate() {
  177.         return missionReferenceDate;
  178.     }

  180.     /** Set IERS conventions.
  181.      * @param newConventions IERS conventions to use while parsing
  182.      * @return a new instance, with IERS conventions replaced
  183.      * @see #getConventions()
  184.      */
  185.     public TDMParser withConventions(final IERSConventions newConventions) {
  186.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), newConventions, isSimpleEOP());
  187.     }

  189.     /** Get IERS conventions.
  190.      * @return IERS conventions to use while parsing
  191.      * @see #withConventions(IERSConventions)
  192.      */
  193.     public IERSConventions getConventions() {
  194.         return conventions;
  195.     }

  197.     /** Set EOP interpolation method.
  198.      * @param newSimpleEOP if true, tidal effects are ignored when interpolating EOP
  199.      * @return a new instance, with EOP interpolation method replaced
  200.      * @see #isSimpleEOP()
  201.      */
  202.     public TDMParser withSimpleEOP(final boolean newSimpleEOP) {
  203.         return new TDMParser(getFileFormat(), getMissionReferenceDate(), getConventions(), newSimpleEOP);
  204.     }

  206.     /** Get EOP interpolation method.
  207.      * @return true if tidal effects are ignored when interpolating EOP
  208.      * @see #withSimpleEOP(boolean)
  209.      */
  210.     public boolean isSimpleEOP() {
  211.         return simpleEOP;
  212.     }

  214.     /** Parse a CCSDS Tracking Data Message.
  215.      * @param fileName name of the file containing the message
  216.      * @return parsed file content in a TDMFile object
  217.      * @exception OrekitException if Tracking Date Message cannot be parsed or if file cannot be found
  218.      */
  219.     public TDMFile parse(final String fileName)
  220.         throws OrekitException {
  221.         try (InputStream stream = new FileInputStream(fileName)) {
  222.             return parse(stream, fileName);
  223.         } catch (IOException ioe) {
  224.             throw new OrekitException(OrekitMessages.UNABLE_TO_FIND_FILE, fileName);
  225.         }
  226.     }

  228.     /** Parse a CCSDS Tracking Data Message.
  229.      * @param stream stream containing message
  230.      * @return parsed file content in a TDMFile object
  231.      * @exception OrekitException if Tracking Date Message cannot be parsed
  232.      */
  233.     public TDMFile parse(final InputStream stream)
  234.         throws OrekitException {
  235.         return parse(stream, "<unknown>");
  236.     }

  238.     /** Parse a CCSDS Tracking Data Message.
  239.      * @param stream stream containing message
  240.      * @param fileName name of the file containing the message (for error messages)
  241.      * @return parsed file content in a TDMFile object
  242.      * @exception OrekitException if Tracking Date Message cannot be parsed or format is unknown
  243.      */
  244.     public TDMFile parse(final InputStream stream, final String fileName)
  245.         throws  OrekitException {

  247.         // Set the format of the file automatically
  248.         // If it is obvious and was not formerly specified
  249.         // Then, use a different parsing method for each file format
  250.         if (TDMFileFormat.UNKNOWN.equals(fileFormat)) {
  251.             if (fileName.toLowerCase().endsWith(".txt")) {
  252.                 // Keyvalue format case
  253.                 return this.withFileFormat(TDMFileFormat.KEYVALUE).parse(stream, fileName);
  254.             } else if (fileName.toLowerCase().endsWith(".xml")) {
  255.                 // XML format case
  256.                 return this.withFileFormat(TDMFileFormat.XML).parse(stream, fileName);
  257.             } else {
  258.                 throw new OrekitException(OrekitMessages.CCSDS_TDM_UNKNOWN_FORMAT, fileName);
  259.             }
  260.         } else if (this.fileFormat.equals(TDMFileFormat.KEYVALUE)) {
  261.             return parseKeyValue(stream, fileName);
  262.         } else if (this.fileFormat.equals(TDMFileFormat.XML)) {
  263.             return parseXml(stream, fileName);
  264.         } else {
  265.             throw new OrekitException(OrekitMessages.CCSDS_TDM_UNKNOWN_FORMAT, fileName);
  266.         }
  267.     }

  269.     /** Parse a CCSDS Tracking Data Message with KEYVALUE format.
  270.      * @param stream stream containing message
  271.      * @param fileName name of the file containing the message (for error messages)
  272.      * @return parsed file content in a TDMFile object
  273.      * @exception OrekitException if Tracking Date Message cannot be parsed
  274.      */
  275.     public TDMFile parseKeyValue(final InputStream stream, final String fileName)
  276.         throws  OrekitException {

  278.         final KeyValueHandler handler = new KeyValueHandler(new ParseInfo(this.getMissionReferenceDate(),
  279.                                                                     this.getConventions(),
  280.                                                                     this.isSimpleEOP(),
  281.                                                                     fileName));
  282.         return handler.parse(stream, fileName);
  283.     }



  287.     /** Parse a CCSDS Tracking Data Message with XML format.
  288.      * @param stream stream containing message
  289.      * @param fileName name of the file containing the message (for error messages)
  290.      * @return parsed file content in a TDMFile object
  291.      * @exception OrekitException if Tracking Date Message cannot be parsed
  292.      */
  293.     public TDMFile parseXml(final InputStream stream, final String fileName)
  294.         throws OrekitException {
  295.         try {
  296.             // Create the handler
  297.             final XMLHandler handler = new XMLHandler(new ParseInfo(this.getMissionReferenceDate(),
  298.                                                                     this.getConventions(),
  299.                                                                     this.isSimpleEOP(),
  300.                                                                     fileName));

  302.             // Create the XML SAX parser factory
  303.             final SAXParserFactory factory = SAXParserFactory.newInstance();

  305.             // Build the parser and read the xml file
  306.             final SAXParser parser = factory.newSAXParser();
  307.             parser.parse(stream, handler);

  309.             // Get the content of the file
  310.             final TDMFile tdmFile = handler.parseInfo.tdmFile;

  312.             // Check time systems consistency
  313.             tdmFile.checkTimeSystems();

  315.             return tdmFile;
  316.         } catch (ParserConfigurationException | SAXException | IOException e) {
  317.             // throw caught exception as an OrekitException
  318.             throw new OrekitException(e, new DummyLocalizable(e.getMessage()));
  319.         }
  320.     }

  322.     /** Private class used to stock TDM parsing info.
  323.      * @author sports
  324.      */
  325.     private static class ParseInfo {

  327.         /** Reference date for Mission Elapsed Time or Mission Relative Time time systems. */
  328.         private final AbsoluteDate missionReferenceDate;

  330.         /** IERS Conventions. */
  331.         private final  IERSConventions conventions;

  333.         /** Indicator for simple or accurate EOP interpolation. */
  334.         private final  boolean simpleEOP;

  336.         /** Name of the file. */
  337.         private String fileName;

  339.         /** Current Observation Block being parsed. */
  340.         private TDMFile.ObservationsBlock currentObservationsBlock;

  342.         /** Current line number. */
  343.         private int lineNumber;

  345.         /** Current parsed line. */
  346.         private String line;

  348.         /** TDMFile object being filled. */
  349.         private TDMFile tdmFile;

  351.         /** Key value of the current line being read. */
  352.         private KeyValue keyValue;

  354.         /** Temporary stored comments. */
  355.         private List<String> commentTmp;

  357.         /** Boolean indicating if the parser is currently parsing a meta-data block. */
  358.         private boolean parsingMetaData;

  360.         /** Boolean indicating if the parser is currently parsing a data block. */
  361.         private boolean parsingData;

  363.         /** Complete constructor.
  364.          * @param missionReferenceDate reference date for Mission Elapsed Time or Mission Relative Time time systems
  365.          * @param conventions IERS Conventions
  366.          * @param simpleEOP if true, tidal effects are ignored when interpolating EOP
  367.          * @param fileName the name of the file being parsed
  368.          */
  369.         private ParseInfo(final AbsoluteDate missionReferenceDate,
  370.                           final IERSConventions conventions,
  371.                           final boolean simpleEOP,
  372.                           final String fileName) {
  373.             this.missionReferenceDate = missionReferenceDate;
  374.             this.conventions          = conventions;
  375.             this.simpleEOP            = simpleEOP;
  376.             this.fileName             = fileName;
  377.             this.lineNumber = 0;
  378.             this.line = "";
  379.             this.tdmFile = new TDMFile();
  380.             this.commentTmp = new ArrayList<String>();
  381.             this.currentObservationsBlock = null;
  382.             this.parsingMetaData = false;
  383.             this.parsingData     = false;
  384.         }

  386.         /** Parse a meta-data entry.<p>
  387.          * key = value (KEYVALUE file format)<p>
  388.          * <&lt;key>value&lt;/key> (XML file format)
  389.          * @exception OrekitException if error in /parsing dates or if parsing integer or double fails
  390.          */
  391.         private void parseMetaDataEntry() throws OrekitException {

  393.             final TDMFile.TDMMetaData metaData = this.currentObservationsBlock.getMetaData();

  395.             try {
  396.                 switch (keyValue.getKeyword()) {
  397.                     case TIME_SYSTEM:
  398.                         // Read the time system and ensure that it is supported by Orekit
  399.                         if (!CcsdsTimeScale.contains(keyValue.getValue())) {
  400.                             throw new OrekitException(OrekitMessages.CCSDS_TIME_SYSTEM_NOT_IMPLEMENTED,
  401.                                                       keyValue.getValue());
  402.                         }
  403.                         final CcsdsTimeScale timeSystem =
  404.                                         CcsdsTimeScale.valueOf(keyValue.getValue());
  405.                         metaData.setTimeSystem(timeSystem);

  407.                         // Convert start/stop time to AbsoluteDate if they have been read already
  408.                         if (metaData.getStartTimeString() != null) {
  409.                             metaData.setStartTime(parseDate(metaData.getStartTimeString(), timeSystem));
  410.                         }
  411.                         if (metaData.getStopTimeString() != null) {
  412.                             metaData.setStopTime(parseDate(metaData.getStopTimeString(), timeSystem));
  413.                         }
  414.                         break;

  416.                     case START_TIME:
  417.                         // Set the start time as a String first
  418.                         metaData.setStartTimeString(keyValue.getValue());

  420.                         // If time system has already been defined, convert the start time to an AbsoluteDate
  421.                         if (metaData.getTimeSystem() != null) {
  422.                             metaData.setStartTime(parseDate(keyValue.getValue(), metaData.getTimeSystem()));
  423.                         }
  424.                         break;

  426.                     case STOP_TIME:
  427.                         // Set the stop time as a String first
  428.                         metaData.setStopTimeString(keyValue.getValue());

  430.                         // If time system has already been defined, convert the start time to an AbsoluteDate
  431.                         if (metaData.getTimeSystem() != null) {
  432.                             metaData.setStopTime(parseDate(keyValue.getValue(), metaData.getTimeSystem()));
  433.                         }
  434.                         break;

  436.                     case PARTICIPANT_1: case PARTICIPANT_2: case PARTICIPANT_3:
  437.                     case PARTICIPANT_4: case PARTICIPANT_5:
  438.                         // Get the participant number
  439.                         String key = keyValue.getKey();
  440.                         int participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  442.                         // Add the tuple to the map
  443.                         metaData.addParticipant(participantNumber, keyValue.getValue());
  444.                         break;

  446.                     case MODE:
  447.                         metaData.setMode(keyValue.getValue());
  448.                         break;

  450.                     case PATH:
  451.                         metaData.setPath(keyValue.getValue());
  452.                         break;

  454.                     case PATH_1:
  455.                         metaData.setPath1(keyValue.getValue());
  456.                         break;

  458.                     case PATH_2:
  459.                         metaData.setPath2(keyValue.getValue());
  460.                         break;

  462.                     case TRANSMIT_BAND:
  463.                         metaData.setTransmitBand(keyValue.getValue());
  464.                         break;

  466.                     case RECEIVE_BAND:
  467.                         metaData.setReceiveBand(keyValue.getValue());
  468.                         break;

  470.                     case TURNAROUND_NUMERATOR:
  471.                         metaData.setTurnaroundNumerator(keyValue.getIntegerValue());
  472.                         break;

  474.                     case TURNAROUND_DENOMINATOR:
  475.                         metaData.setTurnaroundDenominator(keyValue.getIntegerValue());
  476.                         break;

  478.                     case TIMETAG_REF:
  479.                         metaData.setTimetagRef(keyValue.getValue());
  480.                         break;

  482.                     case INTEGRATION_INTERVAL:
  483.                         metaData.setIntegrationInterval(keyValue.getDoubleValue());
  484.                         break;

  486.                     case INTEGRATION_REF:
  487.                         metaData.setIntegrationRef(keyValue.getValue());
  488.                         break;

  490.                     case FREQ_OFFSET:
  491.                         metaData.setFreqOffset(keyValue.getDoubleValue());
  492.                         break;

  494.                     case RANGE_MODE:
  495.                         metaData.setRangeMode(keyValue.getValue());
  496.                         break;

  498.                     case RANGE_MODULUS:
  499.                         metaData.setRangeModulus(keyValue.getDoubleValue());
  500.                         break;

  502.                     case RANGE_UNITS:
  503.                         metaData.setRangeUnits(keyValue.getValue());
  504.                         break;

  506.                     case ANGLE_TYPE:
  507.                         metaData.setAngleType(keyValue.getValue());
  508.                         break;

  510.                     case REFERENCE_FRAME:
  511.                         metaData.setReferenceFrameString(keyValue.getValue());
  512.                         metaData.setReferenceFrame(parseCCSDSFrame(keyValue.getValue()).getFrame(this.conventions, this.simpleEOP));
  513.                         break;

  515.                     case TRANSMIT_DELAY_1: case TRANSMIT_DELAY_2: case TRANSMIT_DELAY_3:
  516.                     case TRANSMIT_DELAY_4: case TRANSMIT_DELAY_5:
  517.                         // Get the participant number
  518.                         key = keyValue.getKey();
  519.                         participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  521.                         // Add the tuple to the map
  522.                         metaData.addTransmitDelay(participantNumber, keyValue.getDoubleValue());
  523.                         break;

  525.                     case RECEIVE_DELAY_1: case RECEIVE_DELAY_2: case RECEIVE_DELAY_3:
  526.                     case RECEIVE_DELAY_4: case RECEIVE_DELAY_5:
  527.                         // Get the participant number
  528.                         key = keyValue.getKey();
  529.                         participantNumber = Integer.parseInt(key.substring(key.length() - 1));

  531.                         // Add the tuple to the map
  532.                         metaData.addReceiveDelay(participantNumber, keyValue.getDoubleValue());
  533.                         break;

  535.                     case DATA_QUALITY:
  536.                         metaData.setDataQuality(keyValue.getValue());
  537.                         break;

  539.                     case CORRECTION_ANGLE_1:
  540.                         metaData.setCorrectionAngle1(keyValue.getDoubleValue());
  541.                         break;

  543.                     case CORRECTION_ANGLE_2:
  544.                         metaData.setCorrectionAngle2(keyValue.getDoubleValue());
  545.                         break;

  547.                     case CORRECTION_DOPPLER:
  548.                         metaData.setCorrectionDoppler(keyValue.getDoubleValue());
  549.                         break;

  551.                     case CORRECTION_RANGE:
  552.                         metaData.setCorrectionRange(keyValue.getDoubleValue());
  553.                         break;

  555.                     case CORRECTION_RECEIVE:
  556.                         metaData.setCorrectionReceive(keyValue.getDoubleValue());
  557.                         break;

  559.                     case CORRECTION_TRANSMIT:
  560.                         metaData.setCorrectionTransmit(keyValue.getDoubleValue());
  561.                         break;

  563.                     case CORRECTIONS_APPLIED:
  564.                         metaData.setCorrectionsApplied(keyValue.getValue());
  565.                         break;

  567.                     default:
  568.                         throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, lineNumber, fileName, line);
  569.                 }
  570.             } catch (NumberFormatException nfe) {
  571.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  572.                                           lineNumber, fileName, line);
  573.             }
  574.         }

  576.         /** Parse a CCSDS frame.
  577.          * @param frameName name of the frame, as the value of a CCSDS key=value line
  578.          * @return CCSDS frame corresponding to the name
  579.          */
  580.         private CCSDSFrame parseCCSDSFrame(final String frameName) {
  581.             return CCSDSFrame.valueOf(frameName.replaceAll("-", ""));
  582.         }

  584.         /** Parse a date.
  585.          * @param date date to parse, as the value of a CCSDS key=value line
  586.          * @param timeSystem time system to use
  587.          * @return parsed date
  588.          * @exception OrekitException if some time scale cannot be retrieved
  589.          */
  590.         private AbsoluteDate parseDate(final String date, final CcsdsTimeScale timeSystem)
  591.                         throws OrekitException {
  592.             return timeSystem.parseDate(date, conventions, missionReferenceDate);
  593.         }
  594.     }

  596.     /** Handler for parsing KEYVALUE file formats. */
  597.     private static class KeyValueHandler {

  599.         /** ParseInfo object. */
  600.         private ParseInfo parseInfo;

  602.         /** Simple constructor.
  603.          * @param parseInfo ParseInfo object
  604.          */
  605.         KeyValueHandler(final ParseInfo parseInfo) {
  606.             this.parseInfo       = parseInfo;
  607.         }

  609.         /**
  610.          * Parse an observation data line and add its content to the Observations Block
  611.          * block.
  612.          *
  613.          * @exception OrekitException if error in parsing dates or inconsistent data lines or in number conversion from String
  614.          */
  615.         private void parseObservationsDataLine()
  616.                         throws OrekitException {

  618.             // Parse an observation line
  619.             // An observation line should consist in the string "keyword = epoch value"
  620.             // parseInfo.keyValue.getValue() should return the string "epoch value"
  621.             final String[] fields = parseInfo.keyValue.getValue().split("\\s+");

  623.             // Check that there are 2 fields in the value of the key
  624.             if (fields.length != 2) {
  625.                 throw new OrekitException(OrekitMessages.CCSDS_TDM_INCONSISTENT_DATA_LINE,
  626.                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  627.             }

  629.             // Convert the date to an AbsoluteDate object (OrekitException if it fails)
  630.             final AbsoluteDate epoch = parseInfo.parseDate(fields[0], parseInfo.currentObservationsBlock.getMetaData().getTimeSystem());
  631.             final double measurement;
  632.             try {
  633.                 // Convert the value to double (NumberFormatException if it fails)
  634.                 measurement = Double.parseDouble(fields[1]);
  635.             } catch (NumberFormatException nfe) {
  636.                 throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  637.                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  638.             }

  640.             // Adds the observation to current observation block
  641.             parseInfo.currentObservationsBlock.addObservation(parseInfo.keyValue.getKeyword().name(),
  642.                                                        epoch,
  643.                                                        measurement);
  644.         }

  646.         /** Parse a CCSDS Tracking Data Message with KEYVALUE format.
  647.          * @param stream stream containing message
  648.          * @param fileName name of the file containing the message (for error messages)
  649.          * @return parsed file content in a TDMFile object
  650.          * @exception OrekitException if stream cannot be read or Tracking Date Message cannot be parsed
  651.          */
  652.         public TDMFile parse(final InputStream stream, final String fileName)
  653.                         throws  OrekitException {
  654.             try (BufferedReader reader = new BufferedReader(new InputStreamReader(stream, "UTF-8"))) {
  655.                 try {
  656.                     // Initialize internal TDMFile
  657.                     final TDMFile tdmFile = parseInfo.tdmFile;

  659.                     // Read the file
  660.                     for (String line = reader.readLine(); line != null; line = reader.readLine()) {
  661.                         ++parseInfo.lineNumber;
  662.                         if (line.trim().length() == 0) {
  663.                             continue;
  664.                         }
  665.                         parseInfo.line = line;
  666.                         parseInfo.keyValue = new KeyValue(parseInfo.line, parseInfo.lineNumber, parseInfo.fileName);
  667.                         if (parseInfo.keyValue.getKeyword() == null) {
  668.                             throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD, parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  669.                         }
  670.                         switch (parseInfo.keyValue.getKeyword()) {

  672.                             // Header entries
  673.                             case CCSDS_TDM_VERS:
  674.                                 // Set CCSDS TDM version
  675.                                 tdmFile.setFormatVersion(parseInfo.keyValue.getDoubleValue());
  676.                                 break;

  678.                             case CREATION_DATE:
  679.                                 // Save current comment in header
  680.                                 tdmFile.setHeaderComment(parseInfo.commentTmp);
  681.                                 parseInfo.commentTmp.clear();
  682.                                 // Set creation date
  683.                                 tdmFile.setCreationDate(new AbsoluteDate(parseInfo.keyValue.getValue(), TimeScalesFactory.getUTC()));
  684.                                 break;

  686.                             case ORIGINATOR:
  687.                                 // Set originator
  688.                                 tdmFile.setOriginator(parseInfo.keyValue.getValue());
  689.                                 break;

  691.                                 // Comments
  692.                             case COMMENT:
  693.                                 parseInfo.commentTmp.add(parseInfo.keyValue.getValue());
  694.                                 break;

  696.                                 // Start/Strop keywords
  697.                             case META_START:
  698.                                 // Add an observation block and set the last observation block to the current
  699.                                 tdmFile.addObservationsBlock();
  700.                                 parseInfo.currentObservationsBlock = tdmFile.getObservationsBlocks().get(tdmFile.getObservationsBlocks().size() - 1);
  701.                                 // Indicate the start of meta-data parsing for this block
  702.                                 parseInfo.parsingMetaData = true;
  703.                                 break;

  705.                             case META_STOP:
  706.                                 // Save current comment in current meta-data comment
  707.                                 parseInfo.currentObservationsBlock.getMetaData().setComment(parseInfo.commentTmp);
  708.                                 parseInfo.commentTmp.clear();
  709.                                 // Indicate the end of meta-data parsing for this block
  710.                                 parseInfo.parsingMetaData = false;
  711.                                 break;

  713.                             case DATA_START:
  714.                                 // Indicate the start of data parsing for this block
  715.                                 parseInfo.parsingData = true;
  716.                                 break;

  718.                             case DATA_STOP:
  719.                                 // Save current comment in current Observation Block comment
  720.                                 parseInfo.currentObservationsBlock.setObservationsComment(parseInfo.commentTmp);
  721.                                 parseInfo.commentTmp.clear();
  722.                                 // Indicate the end of data parsing for this block
  723.                                 parseInfo.parsingData = false;
  724.                                 break;

  726.                             default:
  727.                                 // Parse a line that does not display the previous keywords
  728.                                 if ((parseInfo.currentObservationsBlock != null) &&
  729.                                      (parseInfo.parsingData || parseInfo.parsingMetaData)) {
  730.                                     if (parseInfo.parsingMetaData) {
  731.                                         // Parse a meta-data line
  732.                                         parseInfo.parseMetaDataEntry();
  733.                                     } else {
  734.                                         // Parse an observation data line
  735.                                         this.parseObservationsDataLine();
  736.                                     }
  737.                                 } else {
  738.                                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  739.                                                               parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  740.                                 }
  741.                                 break;
  742.                         }
  743.                     }
  744.                     // Check time systems consistency before returning the parsed content
  745.                     tdmFile.checkTimeSystems();
  746.                     return tdmFile;
  747.                 } catch (IOException ioe) {
  748.                     throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  749.                 }
  750.             } catch (IOException ioe) {
  751.                 throw new OrekitException(ioe, new DummyLocalizable(ioe.getMessage()));
  752.             }
  753.         }
  754.     }

  756.     /** Handler for parsing XML file formats. */
  757.     private static class XMLHandler extends DefaultHandler {

  759.         /** ParseInfo object. */
  760.         private ParseInfo parseInfo;

  762.         /** Locator used to get current line number. */
  763.         private Locator locator;

  765.         /** Current keyword being read. */
  766.         private Keyword currentKeyword;

  768.         /** Current observation keyword being read. */
  769.         private Keyword currentObservationKeyword;

  771.         /** Current observation epoch being read. */
  772.         private AbsoluteDate currentObservationEpoch;

  774.         /** Current observation measurement being read. */
  775.         private double currentObservationMeasurement;

  777.         /** Simple constructor.
  778.          * @param parseInfo ParseInfo object
  779.          */
  780.         XMLHandler(final ParseInfo parseInfo) {
  781.             this.parseInfo      = parseInfo;
  782.             this.locator        = null;
  783.             this.currentKeyword = null;
  784.             this.currentObservationKeyword      = null;
  785.             this.currentObservationEpoch        = null;
  786.             this.currentObservationMeasurement  = Double.NaN;
  787.         }

  789.         @Override
  790.         public void setDocumentLocator(final Locator documentLocator) {
  791.             this.locator = documentLocator;
  792.         }

  794.         /**
  795.          * Extract the content of an element.
  796.          *
  797.          * @param ch the characters
  798.          * @param start the index of the first character of the desired content
  799.          * @param length the length of the content
  800.          * @throws SAXException in case of an error.
  801.          *
  802.          * @see org.xml.sax.helpers.DefaultHandler#characters(char[], int, int)
  803.          */
  804.         @Override
  805.         public void characters(final char[] ch, final int start, final int length) throws SAXException
  806.         {
  807.             try {
  808.                 // currentKeyword is set to null in function endElement every time an end tag is parsed.
  809.                 // Thus only the characters between a start and an end tags are parsed.
  810.                 if (currentKeyword != null) {
  811.                     // Store the info in a KeyValue object so that we can use the common functions of parseInfo
  812.                     // The SAX locator does not allow the retrieving of the line
  813.                     // So a pseudo-line showing the keyword is reconstructed
  814.                     final String value = new String(ch, start, length);
  815.                     parseInfo.line = "<" + currentKeyword.name() + ">" + value + "<" + "/" + currentKeyword.name() + ">";
  816.                     parseInfo.lineNumber = locator.getLineNumber();
  817.                     parseInfo.keyValue = new KeyValue(currentKeyword, value, parseInfo.line, parseInfo.lineNumber, parseInfo.fileName);

  819.                     // Scan the keyword
  820.                     switch (currentKeyword) {

  822.                         case CREATION_DATE:
  823.                             // Set creation date
  824.                             parseInfo.tdmFile.setCreationDate(new AbsoluteDate(parseInfo.keyValue.getValue(), TimeScalesFactory.getUTC()));
  825.                             break;

  827.                         case ORIGINATOR:
  828.                             // Set originator
  829.                             parseInfo.tdmFile.setOriginator(parseInfo.keyValue.getValue());
  830.                             break;

  832.                         case COMMENT:
  833.                             // Comments
  834.                             parseInfo.commentTmp.add(parseInfo.keyValue.getValue());
  835.                             break;

  837.                         case tdm: case header: case body: case segment:
  838.                         case metadata: case data:case observation:
  839.                             // Do nothing for this tags
  840.                             break;

  842.                         default:
  843.                             // Parse a line that does not display the previous keywords
  844.                             if ((parseInfo.currentObservationsBlock != null) &&
  845.                                  (parseInfo.parsingData || parseInfo.parsingMetaData)) {
  846.                                 if (parseInfo.parsingMetaData) {
  847.                                     // Call meta-data parsing
  848.                                     parseInfo.parseMetaDataEntry();
  849.                                 } else if (parseInfo.parsingData) {
  850.                                     // Call data parsing
  851.                                     parseObservationDataLine();
  852.                                 }
  853.                             } else {
  854.                                 throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  855.                                                           parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  856.                             }
  857.                             break;
  858.                     }
  859.                 }
  860.             } catch (OrekitException e) {
  861.                 // Re-throw the exception as a SAXException
  862.                 throw new SAXException(e);
  863.             }
  864.         }

  866.         /**
  867.          * Detect the beginning of an element.
  868.          *
  869.          * @param uri The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed.
  870.          * @param localName The local name (without prefix), or the empty string if Namespace processing is not being performed.
  871.          * @param qName The qualified name (with prefix), or the empty string if qualified names are not available.
  872.          * @param attributes The attributes attached to the element. If there are no attributes, it shall be an empty Attributes object.
  873.          * @throws SAXException in case of an error
  874.          *
  875.          * @see org.xml.sax.helpers.DefaultHandler#startElement(java.lang.String, java.lang.String, java.lang.String, org.xml.sax.Attributes)
  876.          */
  877.         @Override
  878.         public void startElement(final String uri, final String localName, final String qName, final Attributes attributes) throws SAXException
  879.         {
  880.             // Check if the start element belongs to the standard keywords
  881.             try
  882.             {
  883.                 try {
  884.                     this.currentKeyword = Keyword.valueOf(qName);
  885.                 } catch (IllegalArgumentException e) {
  886.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  887.                                               locator.getLineNumber(),
  888.                                               parseInfo.fileName,
  889.                                               "<" + qName + ">");
  890.                 }
  891.                 switch (currentKeyword) {
  892.                     case tdm:
  893.                         // Get the version number
  894.                         parseInfo.tdmFile.setFormatVersion(Double.parseDouble(attributes.getValue("version")));
  895.                         break;

  897.                     case observation:
  898.                         // Re-initialize the stored observation's attributes
  899.                         this.currentObservationKeyword     = null;
  900.                         this.currentObservationEpoch       = null;
  901.                         this.currentObservationMeasurement = Double.NaN;
  902.                         break;

  904.                     case segment:
  905.                         // Add an observation block and set the last observation block to the current
  906.                         final TDMFile tdmFile = parseInfo.tdmFile;
  907.                         tdmFile.addObservationsBlock();
  908.                         parseInfo.currentObservationsBlock = tdmFile.getObservationsBlocks().get(tdmFile.getObservationsBlocks().size() - 1);
  909.                         break;

  911.                     case metadata:
  912.                         // Indicate the start of meta-data parsing for this block
  913.                         parseInfo.parsingMetaData = true;
  914.                         break;

  916.                     case data:
  917.                         // Indicate the start of data parsing for this block
  918.                         parseInfo.parsingData = true;
  919.                         break;

  921.                     default:
  922.                         // Ignore the element.
  923.                         break;
  924.                 }
  925.             }
  926.             catch (IllegalArgumentException | OrekitException e)
  927.             {
  928.                 throw new SAXException(e);
  929.             }
  930.         }

  932.         /**
  933.          * Detect the end of an element and remove the stored keyword.
  934.          *
  935.          * @param uri The Namespace URI, or the empty string if the element has no Namespace URI or if Namespace processing is not being performed.
  936.          * @param localName The local name (without prefix), or the empty string if Namespace processing is not being performed.
  937.          * @param qName The qualified name (with prefix), or the empty string if qualified names are not available.
  938.          * @throws SAXException in case of an error
  939.          *
  940.          * @see org.xml.sax.helpers.DefaultHandler#endElement(java.lang.String, java.lang.String, java.lang.String)
  941.          */
  942.         @Override
  943.         public void endElement(final String uri, final String localName, final String qName) throws SAXException
  944.         {
  945.             // check if the start element belongs to the standard keywords
  946.             try
  947.             {
  948.                 // Set the stored keyword to null
  949.                 currentKeyword = null;
  950.                 // Ending keyword
  951.                 final Keyword endKeyword;
  952.                 try {
  953.                     endKeyword = Keyword.valueOf(qName);
  954.                 } catch (IllegalArgumentException e) {
  955.                     throw new OrekitException(OrekitMessages.CCSDS_UNEXPECTED_KEYWORD,
  956.                                               locator.getLineNumber(),
  957.                                               parseInfo.fileName,
  958.                                               "</" + qName + ">");
  959.                 }
  960.                 switch (endKeyword) {

  962.                     case header:
  963.                         // Save header comment
  964.                         parseInfo.tdmFile.setHeaderComment(parseInfo.commentTmp);
  965.                         parseInfo.commentTmp.clear();
  966.                         break;

  968.                     case observation:
  969.                         // Check that stored observation's attributes were all found
  970.                         if (currentObservationKeyword == null         ||
  971.                             currentObservationEpoch == null           ||
  972.                             Double.isNaN(currentObservationMeasurement)) {
  973.                             throw new OrekitException(OrekitMessages.CCSDS_TDM_XML_INCONSISTENT_DATA_BLOCK,
  974.                                                       locator.getLineNumber(),
  975.                                                       parseInfo.fileName);
  976.                         } else {
  977.                             // Add current observation
  978.                             parseInfo.currentObservationsBlock.addObservation(currentObservationKeyword.name(),
  979.                                                                               currentObservationEpoch,
  980.                                                                               currentObservationMeasurement);
  981.                         }
  982.                         break;

  984.                     case segment:
  985.                         // Do nothing
  986.                         break;

  988.                     case metadata:
  989.                         // Save current comment in current meta-data comment
  990.                         parseInfo.currentObservationsBlock.getMetaData().setComment(parseInfo.commentTmp);
  991.                         parseInfo.commentTmp.clear();
  992.                         // Indicate the end of meta-data parsing for this block
  993.                         parseInfo.parsingMetaData = false;
  994.                         break;

  996.                     case data:
  997.                         // Save current comment in current Observation Block comment
  998.                         parseInfo.currentObservationsBlock.setObservationsComment(parseInfo.commentTmp);
  999.                         parseInfo.commentTmp.clear();
  1000.                         // Indicate the end of data parsing for this block
  1001.                         parseInfo.parsingData = false;
  1002.                         break;

  1004.                     default:
  1005.                         // Ignore the element.
  1006.                 }
  1007.             }
  1008.             catch (IllegalArgumentException | OrekitException e)
  1009.             {
  1010.                 throw new SAXException(e);
  1011.             }
  1012.         }

  1014.         @Override
  1015.         public InputSource resolveEntity(final String publicId, final String systemId) {
  1016.             // disable external entities
  1017.             return new InputSource();
  1018.         }

  1020.         /** Parse a line in an observation data block.
  1021.          * @exception OrekitException if error in parsing dates or in conversion of number from String
  1022.          */
  1023.         private void parseObservationDataLine()
  1024.                         throws OrekitException {

  1026.             // Parse an observation line
  1027.             // An XML observation line should consist in the string "<KEYWORD>value</KEYWORD>
  1028.             // Each observation block should display:
  1029.             //  - One line with the keyword EPOCH;
  1030.             //  - One line with a specific data keyword
  1031.             switch(currentKeyword) {
  1032.                 case EPOCH:
  1033.                     // Convert the date to an AbsoluteDate object (OrekitException if it fails)
  1034.                     currentObservationEpoch = parseInfo.parseDate(parseInfo.keyValue.getValue(),
  1035.                                                        parseInfo.currentObservationsBlock.getMetaData().getTimeSystem());
  1036.                     break;
  1037.                 default:
  1038.                     try {
  1039.                         // Update current observation keyword
  1040.                         currentObservationKeyword = currentKeyword;
  1041.                         // Convert the value to double (NumberFormatException if it fails)
  1042.                         currentObservationMeasurement = Double.parseDouble(parseInfo.keyValue.getValue());
  1043.                     } catch (NumberFormatException nfe) {
  1044.                         throw new OrekitException(OrekitMessages.UNABLE_TO_PARSE_LINE_IN_FILE,
  1045.                                                   parseInfo.lineNumber, parseInfo.fileName, parseInfo.line);
  1046.                     }
  1047.                     break;
  1048.             }
  1049.         }
  1050.     }
  1051. }
Created with JaCoCo 0.7.9.201702052155